Index: branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/BaselineClassifiers/OneFactorClassificationModel.cs
===================================================================
--- branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/BaselineClassifiers/OneFactorClassificationModel.cs	(revision 14926)
+++ branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/BaselineClassifiers/OneFactorClassificationModel.cs	(revision 14927)
@@ -25,9 +25,9 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Persistence;
 using HeuristicLab.Problems.DataAnalysis;
 
 namespace HeuristicLab.Algorithms.DataAnalysis {
-  [StorableClass]
+  [StorableType("ffc9c4c8-a5ac-42da-8110-bcb9addb2f64")]
   [Item("OneFactor Classification Model", "A model that uses only one categorical feature (factor) to determine the class.")]
   public sealed class OneFactorClassificationModel : ClassificationModel {
Index: branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/BaselineClassifiers/OneFactorClassificationSolution.cs
===================================================================
--- branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/BaselineClassifiers/OneFactorClassificationSolution.cs	(revision 14926)
+++ branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/BaselineClassifiers/OneFactorClassificationSolution.cs	(revision 14927)
@@ -22,9 +22,9 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Persistence;
 using HeuristicLab.Problems.DataAnalysis;
 
 namespace HeuristicLab.Algorithms.DataAnalysis {
-  [StorableClass]
+  [StorableType("8d979771-aa10-488f-8839-5243eac1c4b6")]
   [Item(Name = "OneR Classification Solution", Description = "Represents a OneR classification solution which uses only a single factor for class prediction.")]
   public sealed class OneFactorClassificationSolution : ClassificationSolution {
Index: branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/BaselineClassifiers/OneR.cs
===================================================================
--- branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/BaselineClassifiers/OneR.cs	(revision 14926)
+++ branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/BaselineClassifiers/OneR.cs	(revision 14927)
@@ -29,5 +29,5 @@
 using HeuristicLab.Optimization;
 using HeuristicLab.Parameters;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Persistence;
 using HeuristicLab.Problems.DataAnalysis;
 
@@ -37,5 +37,5 @@
   /// </summary>
   [Item("OneR Classification", "A simple classification algorithm the searches the best single-variable split (does not support categorical features correctly). See R.C. Holte (1993). Very simple classification rules perform well on most commonly used datasets. Machine Learning. 11:63-91.")]
-  [StorableClass]
+  [StorableType("91ed1a56-9638-4834-96eb-f4990e3e4fd8")]
   public sealed class OneR : FixedDataAnalysisAlgorithm<IClassificationProblem> {
 
Index: branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/BaselineClassifiers/OneRClassificationModel.cs
===================================================================
--- branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/BaselineClassifiers/OneRClassificationModel.cs	(revision 14926)
+++ branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/BaselineClassifiers/OneRClassificationModel.cs	(revision 14927)
@@ -25,9 +25,9 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Persistence;
 using HeuristicLab.Problems.DataAnalysis;
 
 namespace HeuristicLab.Algorithms.DataAnalysis {
-  [StorableClass]
+  [StorableType("67b1e15e-6954-47b2-8123-cbf764881e7c")]
   [Item("OneR Classification Model", "A model that uses intervals for one variable to determine the class.")]
   public sealed class OneRClassificationModel : ClassificationModel {
Index: branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/BaselineClassifiers/OneRClassificationSolution.cs
===================================================================
--- branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/BaselineClassifiers/OneRClassificationSolution.cs	(revision 14926)
+++ branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/BaselineClassifiers/OneRClassificationSolution.cs	(revision 14927)
@@ -22,9 +22,9 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Persistence;
 using HeuristicLab.Problems.DataAnalysis;
 
 namespace HeuristicLab.Algorithms.DataAnalysis {
-  [StorableClass]
+  [StorableType("d1e09548-4575-4c93-90d8-fc36a0045ab2")]
   [Item(Name = "OneR Classification Solution", Description = "Represents a OneR classification solution which uses only a single feature with potentially multiple thresholds for class prediction.")]
   public sealed class OneRClassificationSolution : ClassificationSolution {
Index: branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/BaselineClassifiers/ZeroR.cs
===================================================================
--- branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/BaselineClassifiers/ZeroR.cs	(revision 14926)
+++ branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/BaselineClassifiers/ZeroR.cs	(revision 14927)
@@ -25,5 +25,5 @@
 using HeuristicLab.Core;
 using HeuristicLab.Optimization;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Persistence;
 using HeuristicLab.Problems.DataAnalysis;
 
@@ -33,5 +33,5 @@
   /// </summary>
   [Item("ZeroR Classification", "The simplest possible classifier, ZeroR always predicts the majority class.")]
-  [StorableClass]
+  [StorableType("a282ab2a-a50f-4c7f-bcd1-0f046c5ee309")]
   public sealed class ZeroR : FixedDataAnalysisAlgorithm<IClassificationProblem> {
 
Index: branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/CrossValidation.cs
===================================================================
--- branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/CrossValidation.cs	(revision 14926)
+++ branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/CrossValidation.cs	(revision 14927)
@@ -30,5 +30,5 @@
 using HeuristicLab.Data;
 using HeuristicLab.Optimization;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Persistence;
 using HeuristicLab.Problems.DataAnalysis;
 using HeuristicLab.Problems.DataAnalysis.Symbolic;
@@ -38,5 +38,5 @@
   [Item("Cross Validation (CV)", "Cross-validation wrapper for data analysis algorithms.")]
   [Creatable(CreatableAttribute.Categories.DataAnalysis, Priority = 100)]
-  [StorableClass]
+  [StorableType("7893404d-8ea2-4545-b4d6-ead977c4d270")]
   public sealed class CrossValidation : ParameterizedNamedItem, IAlgorithm, IStorableContent {
     private IDataAnalysisProblemData shuffledProblemData;
Index: branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/FixedDataAnalysisAlgorithm.cs
===================================================================
--- branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/FixedDataAnalysisAlgorithm.cs	(revision 14926)
+++ branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/FixedDataAnalysisAlgorithm.cs	(revision 14927)
@@ -23,9 +23,9 @@
 using HeuristicLab.Common;
 using HeuristicLab.Optimization;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Persistence;
 using HeuristicLab.Problems.DataAnalysis;
 
 namespace HeuristicLab.Algorithms.DataAnalysis {
-  [StorableClass]
+  [StorableType("d573c0f6-ab27-4f60-adb8-7b4772f4aa9d")]
   public abstract class FixedDataAnalysisAlgorithm<T> : BasicAlgorithm where T : class, IDataAnalysisProblem {
     #region Properties
Index: branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GBM/GradientBoostingRegressionAlgorithm.cs
===================================================================
--- branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GBM/GradientBoostingRegressionAlgorithm.cs	(revision 14926)
+++ branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GBM/GradientBoostingRegressionAlgorithm.cs	(revision 14927)
@@ -32,5 +32,5 @@
 using HeuristicLab.Optimization;
 using HeuristicLab.Parameters;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Persistence;
 using HeuristicLab.Problems.DataAnalysis;
 using HeuristicLab.Problems.DataAnalysis.Symbolic;
@@ -42,5 +42,5 @@
   [Item("Gradient Boosting Machine Regression (GBM)",
     "Gradient boosting for any regression base learner (e.g. MCTS symbolic regression)")]
-  [StorableClass]
+  [StorableType("70f73be5-e56f-49ae-9157-2d7c8ef21041")]
   [Creatable(CreatableAttribute.Categories.DataAnalysisRegression, Priority = 350)]
   public class GradientBoostingRegressionAlgorithm : FixedDataAnalysisAlgorithm<IRegressionProblem> {
@@ -323,6 +323,5 @@
           Results.Add(new Result("EnsembleSolution", ensembleSolution));
         }
-      }
-      finally {
+      } finally {
         // reset everything
         alg.Prepare(true);
@@ -483,6 +482,5 @@
             model = sol.Model;
           }
-        }
-        finally {
+        } finally {
           alg.ExceptionOccurred -= handler;
           alg.Stopped -= handler2;
Index: branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/CovarianceFunctions/CovarianceConst.cs
===================================================================
--- branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/CovarianceFunctions/CovarianceConst.cs	(revision 14926)
+++ branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/CovarianceFunctions/CovarianceConst.cs	(revision 14927)
@@ -25,8 +25,8 @@
 using HeuristicLab.Data;
 using HeuristicLab.Parameters;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Persistence;
 
 namespace HeuristicLab.Algorithms.DataAnalysis {
-  [StorableClass]
+  [StorableType("8e4e6c02-d20d-4f5e-92a7-7f1547edfd5f")]
   [Item(Name = "CovarianceConst",
     Description = "Constant covariance function for Gaussian processes.")]
Index: branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/CovarianceFunctions/CovarianceLinear.cs
===================================================================
--- branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/CovarianceFunctions/CovarianceLinear.cs	(revision 14926)
+++ branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/CovarianceFunctions/CovarianceLinear.cs	(revision 14927)
@@ -23,8 +23,8 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Persistence;
 
 namespace HeuristicLab.Algorithms.DataAnalysis {
-  [StorableClass]
+  [StorableType("6d1ef20a-68d6-46d3-8f62-230345f73164")]
   [Item(Name = "CovarianceLinear", Description = "Linear covariance function for Gaussian processes.")]
   public sealed class CovarianceLinear : Item, ICovarianceFunction {
Index: branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/CovarianceFunctions/CovarianceLinearArd.cs
===================================================================
--- branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/CovarianceFunctions/CovarianceLinearArd.cs	(revision 14926)
+++ branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/CovarianceFunctions/CovarianceLinearArd.cs	(revision 14927)
@@ -27,8 +27,8 @@
 using HeuristicLab.Data;
 using HeuristicLab.Parameters;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Persistence;
 
 namespace HeuristicLab.Algorithms.DataAnalysis {
-  [StorableClass]
+  [StorableType("6e4de939-ae8c-485f-a522-579afc57c1af")]
   [Item(Name = "CovarianceLinearArd",
     Description = "Linear covariance function with automatic relevance determination for Gaussian processes.")]
Index: branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/CovarianceFunctions/CovarianceMask.cs
===================================================================
--- branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/CovarianceFunctions/CovarianceMask.cs	(revision 14926)
+++ branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/CovarianceFunctions/CovarianceMask.cs	(revision 14927)
@@ -25,8 +25,8 @@
 using HeuristicLab.Data;
 using HeuristicLab.Parameters;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Persistence;
 
 namespace HeuristicLab.Algorithms.DataAnalysis {
-  [StorableClass]
+  [StorableType("43ed3d03-4320-4510-a64f-c0f5c5f4b353")]
   [Item(Name = "CovarianceMask",
     Description = "Masking covariance function for dimension selection can be used to apply a covariance function only on certain input dimensions.")]
Index: branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/CovarianceFunctions/CovarianceMaternIso.cs
===================================================================
--- branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/CovarianceFunctions/CovarianceMaternIso.cs	(revision 14926)
+++ branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/CovarianceFunctions/CovarianceMaternIso.cs	(revision 14927)
@@ -27,8 +27,8 @@
 using HeuristicLab.Data;
 using HeuristicLab.Parameters;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Persistence;
 
 namespace HeuristicLab.Algorithms.DataAnalysis {
-  [StorableClass]
+  [StorableType("7a505f0e-4526-4ebf-8438-d4ccb886a30d")]
   [Item(Name = "CovarianceMaternIso",
     Description = "Matern covariance function for Gaussian processes.")]
Index: branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/CovarianceFunctions/CovarianceNeuralNetwork.cs
===================================================================
--- branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/CovarianceFunctions/CovarianceNeuralNetwork.cs	(revision 14926)
+++ branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/CovarianceFunctions/CovarianceNeuralNetwork.cs	(revision 14927)
@@ -26,8 +26,8 @@
 using HeuristicLab.Data;
 using HeuristicLab.Parameters;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Persistence;
 
 namespace HeuristicLab.Algorithms.DataAnalysis {
-  [StorableClass]
+  [StorableType("b573cc73-f30c-49ba-8fdf-eee1f8561131")]
   [Item(Name = "CovarianceNeuralNetwork",
     Description = "Neural network covariance function for Gaussian processes.")]
Index: branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/CovarianceFunctions/CovarianceNoise.cs
===================================================================
--- branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/CovarianceFunctions/CovarianceNoise.cs	(revision 14926)
+++ branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/CovarianceFunctions/CovarianceNoise.cs	(revision 14927)
@@ -25,8 +25,8 @@
 using HeuristicLab.Data;
 using HeuristicLab.Parameters;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Persistence;
 
 namespace HeuristicLab.Algorithms.DataAnalysis {
-  [StorableClass]
+  [StorableType("f3ba7bba-cbf3-4db2-97bb-95aa891aba99")]
   [Item(Name = "CovarianceNoise",
     Description = "Noise covariance function for Gaussian processes.")]
Index: branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/CovarianceFunctions/CovariancePeriodic.cs
===================================================================
--- branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/CovarianceFunctions/CovariancePeriodic.cs	(revision 14926)
+++ branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/CovarianceFunctions/CovariancePeriodic.cs	(revision 14927)
@@ -26,8 +26,8 @@
 using HeuristicLab.Data;
 using HeuristicLab.Parameters;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Persistence;
 
 namespace HeuristicLab.Algorithms.DataAnalysis {
-  [StorableClass]
+  [StorableType("2b7c587e-45ff-4ea6-b952-eb3f4f5c7433")]
   [Item(Name = "CovariancePeriodic", Description = "Periodic covariance function for Gaussian processes.")]
   public sealed class CovariancePeriodic : ParameterizedNamedItem, ICovarianceFunction {
@@ -150,5 +150,5 @@
       gradient *= gradient;
       var g = new List<double>(3);
-      if (!fixedInverseLength) 
+      if (!fixedInverseLength)
         g.Add(4.0 * scale * Math.Exp(-2.0 * gradient) * gradient);
       if (!fixedPeriod) {
Index: branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/CovarianceFunctions/CovariancePiecewisePolynomial.cs
===================================================================
--- branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/CovarianceFunctions/CovariancePiecewisePolynomial.cs	(revision 14926)
+++ branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/CovarianceFunctions/CovariancePiecewisePolynomial.cs	(revision 14927)
@@ -27,8 +27,8 @@
 using HeuristicLab.Data;
 using HeuristicLab.Parameters;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Persistence;
 
 namespace HeuristicLab.Algorithms.DataAnalysis {
-  [StorableClass]
+  [StorableType("7b299d9e-ff06-4f07-a543-838dff8c7245")]
   [Item(Name = "CovariancePiecewisePolynomial",
     Description = "Piecewise polynomial covariance function with compact support for Gaussian processes.")]
Index: branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/CovarianceFunctions/CovariancePolynomial.cs
===================================================================
--- branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/CovarianceFunctions/CovariancePolynomial.cs	(revision 14926)
+++ branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/CovarianceFunctions/CovariancePolynomial.cs	(revision 14927)
@@ -26,8 +26,8 @@
 using HeuristicLab.Data;
 using HeuristicLab.Parameters;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Persistence;
 
 namespace HeuristicLab.Algorithms.DataAnalysis {
-  [StorableClass]
+  [StorableType("a5763ac6-b57a-4ee8-9126-9fcd89836819")]
   [Item(Name = "CovariancePolynomial",
     Description = "Polynomial covariance function for Gaussian processes.")]
Index: branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/CovarianceFunctions/CovarianceProduct.cs
===================================================================
--- branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/CovarianceFunctions/CovarianceProduct.cs	(revision 14926)
+++ branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/CovarianceFunctions/CovarianceProduct.cs	(revision 14927)
@@ -25,8 +25,8 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Persistence;
 
 namespace HeuristicLab.Algorithms.DataAnalysis {
-  [StorableClass]
+  [StorableType("c78e8a95-28f2-4b0a-88b5-6f43d6636521")]
   [Item(Name = "CovarianceProduct",
     Description = "Product covariance function for Gaussian processes.")]
Index: branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/CovarianceFunctions/CovarianceRationalQuadraticArd.cs
===================================================================
--- branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/CovarianceFunctions/CovarianceRationalQuadraticArd.cs	(revision 14926)
+++ branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/CovarianceFunctions/CovarianceRationalQuadraticArd.cs	(revision 14927)
@@ -27,8 +27,8 @@
 using HeuristicLab.Data;
 using HeuristicLab.Parameters;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Persistence;
 
 namespace HeuristicLab.Algorithms.DataAnalysis {
-  [StorableClass]
+  [StorableType("62f749f2-ac39-47c4-9bc5-6ce6db8b156c")]
   [Item(Name = "CovarianceRationalQuadraticArd",
     Description = "Rational quadratic covariance function with automatic relevance determination for Gaussian processes.")]
Index: branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/CovarianceFunctions/CovarianceRationalQuadraticIso.cs
===================================================================
--- branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/CovarianceFunctions/CovarianceRationalQuadraticIso.cs	(revision 14926)
+++ branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/CovarianceFunctions/CovarianceRationalQuadraticIso.cs	(revision 14927)
@@ -26,8 +26,8 @@
 using HeuristicLab.Data;
 using HeuristicLab.Parameters;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Persistence;
 
 namespace HeuristicLab.Algorithms.DataAnalysis {
-  [StorableClass]
+  [StorableType("8a969770-6bcd-48a0-9af9-8c34b50c788b")]
   [Item(Name = "CovarianceRationalQuadraticIso",
     Description = "Isotropic rational quadratic covariance function for Gaussian processes.")]
Index: branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/CovarianceFunctions/CovarianceScale.cs
===================================================================
--- branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/CovarianceFunctions/CovarianceScale.cs	(revision 14926)
+++ branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/CovarianceFunctions/CovarianceScale.cs	(revision 14927)
@@ -27,8 +27,8 @@
 using HeuristicLab.Data;
 using HeuristicLab.Parameters;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Persistence;
 
 namespace HeuristicLab.Algorithms.DataAnalysis {
-  [StorableClass]
+  [StorableType("5cc3cd9a-6ff9-4cd5-bb15-c39ba5919596")]
   [Item(Name = "CovarianceScale",
     Description = "Scale covariance function for Gaussian processes.")]
Index: branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/CovarianceFunctions/CovarianceSpectralMixture.cs
===================================================================
--- branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/CovarianceFunctions/CovarianceSpectralMixture.cs	(revision 14926)
+++ branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/CovarianceFunctions/CovarianceSpectralMixture.cs	(revision 14927)
@@ -27,8 +27,8 @@
 using HeuristicLab.Data;
 using HeuristicLab.Parameters;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Persistence;
 
 namespace HeuristicLab.Algorithms.DataAnalysis {
-  [StorableClass]
+  [StorableType("29fd98f8-a362-427f-8d28-cd5c8de80e29")]
   [Item(Name = "CovarianceSpectralMixture",
     Description = "The spectral mixture kernel described in Wilson A. G. and Adams R.P., Gaussian Process Kernels for Pattern Discovery and Exptrapolation, ICML 2013.")]
Index: branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/CovarianceFunctions/CovarianceSquaredExponentialArd.cs
===================================================================
--- branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/CovarianceFunctions/CovarianceSquaredExponentialArd.cs	(revision 14926)
+++ branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/CovarianceFunctions/CovarianceSquaredExponentialArd.cs	(revision 14927)
@@ -27,8 +27,8 @@
 using HeuristicLab.Data;
 using HeuristicLab.Parameters;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Persistence;
 
 namespace HeuristicLab.Algorithms.DataAnalysis {
-  [StorableClass]
+  [StorableType("305128f4-a64e-4396-adf3-6c7a0b7e5a54")]
   [Item(Name = "CovarianceSquaredExponentialArd", Description = "Squared exponential covariance function with automatic relevance determination for Gaussian processes.")]
   public sealed class CovarianceSquaredExponentialArd : ParameterizedNamedItem, ICovarianceFunction {
Index: branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/CovarianceFunctions/CovarianceSquaredExponentialIso.cs
===================================================================
--- branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/CovarianceFunctions/CovarianceSquaredExponentialIso.cs	(revision 14926)
+++ branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/CovarianceFunctions/CovarianceSquaredExponentialIso.cs	(revision 14927)
@@ -26,8 +26,8 @@
 using HeuristicLab.Data;
 using HeuristicLab.Parameters;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Persistence;
 
 namespace HeuristicLab.Algorithms.DataAnalysis {
-  [StorableClass]
+  [StorableType("7cb73b3a-a9ef-499c-afba-5d4f9f84fbd9")]
   [Item(Name = "CovarianceSquaredExponentialIso",
     Description = "Isotropic squared exponential covariance function for Gaussian processes.")]
Index: branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/CovarianceFunctions/CovarianceSum.cs
===================================================================
--- branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/CovarianceFunctions/CovarianceSum.cs	(revision 14926)
+++ branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/CovarianceFunctions/CovarianceSum.cs	(revision 14927)
@@ -25,8 +25,8 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Persistence;
 
 namespace HeuristicLab.Algorithms.DataAnalysis {
-  [StorableClass]
+  [StorableType("8db41291-bc6e-40d7-92cc-5690853edb8c")]
   [Item(Name = "CovarianceSum",
     Description = "Sum covariance function for Gaussian processes.")]
Index: branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/GaussianProcessBase.cs
===================================================================
--- branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/GaussianProcessBase.cs	(revision 14926)
+++ branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/GaussianProcessBase.cs	(revision 14927)
@@ -29,5 +29,5 @@
 using HeuristicLab.Optimization;
 using HeuristicLab.Parameters;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Persistence;
 using HeuristicLab.Problems.DataAnalysis;
 
@@ -36,5 +36,5 @@
   /// Base class for Gaussian process data analysis algorithms (regression and classification).
   /// </summary>
-  [StorableClass]
+  [StorableType("a8f00d9d-6fa1-413e-9894-b5dd4756399f")]
   public abstract class GaussianProcessBase : EngineAlgorithm {
     protected const string MeanFunctionParameterName = "MeanFunction";
Index: branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/GaussianProcessClassification.cs
===================================================================
--- branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/GaussianProcessClassification.cs	(revision 14926)
+++ branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/GaussianProcessClassification.cs	(revision 14927)
@@ -28,5 +28,5 @@
 using HeuristicLab.Optimization;
 using HeuristicLab.Parameters;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Persistence;
 using HeuristicLab.PluginInfrastructure;
 using HeuristicLab.Problems.DataAnalysis;
@@ -38,5 +38,5 @@
   [Item("Gaussian Process Least-Squares Classification", "Gaussian process least-squares classification data analysis algorithm.")]
   [Creatable(CreatableAttribute.Categories.DataAnalysisClassification, Priority = 160)]
-  [StorableClass]
+  [StorableType("cf258d4e-2155-4613-8fdb-ea54c371949a")]
   public sealed class GaussianProcessClassification : GaussianProcessBase, IStorableContent {
     public string Filename { get; set; }
Index: branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/GaussianProcessClassificationModelCreator.cs
===================================================================
--- branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/GaussianProcessClassificationModelCreator.cs	(revision 14926)
+++ branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/GaussianProcessClassificationModelCreator.cs	(revision 14927)
@@ -27,9 +27,9 @@
 using HeuristicLab.Encodings.RealVectorEncoding;
 using HeuristicLab.Parameters;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Persistence;
 using HeuristicLab.Problems.DataAnalysis;
 
 namespace HeuristicLab.Algorithms.DataAnalysis {
-  [StorableClass]
+  [StorableType("b94fec85-b4e4-462e-991b-6ab808417e1f")]
   [Item(Name = "GaussianProcessClassificationModelCreator",
     Description = "Creates a Gaussian process model for least-squares classification given the data, the hyperparameters, a mean function, and a covariance function.")]
Index: branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/GaussianProcessClassificationSolutionCreator.cs
===================================================================
--- branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/GaussianProcessClassificationSolutionCreator.cs	(revision 14926)
+++ branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/GaussianProcessClassificationSolutionCreator.cs	(revision 14927)
@@ -26,9 +26,9 @@
 using HeuristicLab.Optimization;
 using HeuristicLab.Parameters;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Persistence;
 using HeuristicLab.Problems.DataAnalysis;
 
 namespace HeuristicLab.Algorithms.DataAnalysis {
-  [StorableClass]
+  [StorableType("d23991ca-c9ea-4a9e-ad05-a4b2eddc1044")]
   [Item(Name = "GaussianProcessClassificationSolutionCreator",
     Description = "Creates a Gaussian process solution from a trained model.")]
Index: branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/GaussianProcessCovarianceOptimizationProblem.cs
===================================================================
--- branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/GaussianProcessCovarianceOptimizationProblem.cs	(revision 14926)
+++ branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/GaussianProcessCovarianceOptimizationProblem.cs	(revision 14927)
@@ -28,5 +28,5 @@
 using HeuristicLab.Optimization;
 using HeuristicLab.Parameters;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Persistence;
 using HeuristicLab.Problems.DataAnalysis;
 using HeuristicLab.Problems.Instances;
@@ -36,5 +36,5 @@
   [Item("Gaussian Process Covariance Optimization Problem", "")]
   [Creatable(CreatableAttribute.Categories.GeneticProgrammingProblems, Priority = 300)]
-  [StorableClass]
+  [StorableType("39cd76cf-7c65-4b4c-bdab-0b3224843746")]
   public sealed class GaussianProcessCovarianceOptimizationProblem : SymbolicExpressionTreeProblem, IStatefulItem, IRegressionProblem, IProblemInstanceConsumer<IRegressionProblemData>, IProblemInstanceExporter<IRegressionProblemData> {
     #region static variables and ctor
@@ -327,6 +327,5 @@
         var gradients = model.HyperparameterGradients;
         Array.Copy(gradients, grad, gradients.Length);
-      }
-      catch (ArgumentException) {
+      } catch (ArgumentException) {
         // building the GaussianProcessModel might fail, in this case we return the worst possible objective value
         func = 1.0E+300;
Index: branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/GaussianProcessHyperparameterInitializer.cs
===================================================================
--- branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/GaussianProcessHyperparameterInitializer.cs	(revision 14926)
+++ branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/GaussianProcessHyperparameterInitializer.cs	(revision 14927)
@@ -26,9 +26,9 @@
 using HeuristicLab.Operators;
 using HeuristicLab.Parameters;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Persistence;
 using HeuristicLab.Problems.DataAnalysis;
 
 namespace HeuristicLab.Algorithms.DataAnalysis {
-  [StorableClass]
+  [StorableType("c3012ce4-0e1e-47ff-80e2-1739feb85b78")]
   [Item(Name = "GaussianProcessHyperparameterInitializer",
     Description = "Initializers the hyperparameter vector based on the mean function, covariance function, and number of allowed input variables.")]
Index: branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/GaussianProcessModel.cs
===================================================================
--- branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/GaussianProcessModel.cs	(revision 14926)
+++ branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/GaussianProcessModel.cs	(revision 14927)
@@ -25,5 +25,5 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Persistence;
 using HeuristicLab.Problems.DataAnalysis;
 
@@ -32,5 +32,5 @@
   /// Represents a Gaussian process model.
   /// </summary>
-  [StorableClass]
+  [StorableType("36ca62fa-4766-4269-b5f1-3bc24c0ed2e1")]
   [Item("GaussianProcessModel", "Represents a Gaussian process posterior.")]
   public sealed class GaussianProcessModel : RegressionModel, IGaussianProcessModel {
Index: branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/GaussianProcessModelCreator.cs
===================================================================
--- branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/GaussianProcessModelCreator.cs	(revision 14926)
+++ branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/GaussianProcessModelCreator.cs	(revision 14927)
@@ -26,8 +26,8 @@
 using HeuristicLab.Operators;
 using HeuristicLab.Parameters;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Persistence;
 
 namespace HeuristicLab.Algorithms.DataAnalysis {
-  [StorableClass]
+  [StorableType("79b97e42-8692-4d3d-b220-1e94249af841")]
   // base class for GaussianProcessModelCreators (specific for classification and regression)
   public abstract class GaussianProcessModelCreator : SingleSuccessorOperator {
Index: branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/GaussianProcessRegression.cs
===================================================================
--- branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/GaussianProcessRegression.cs	(revision 14926)
+++ branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/GaussianProcessRegression.cs	(revision 14927)
@@ -28,5 +28,5 @@
 using HeuristicLab.Optimization;
 using HeuristicLab.Parameters;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Persistence;
 using HeuristicLab.PluginInfrastructure;
 using HeuristicLab.Problems.DataAnalysis;
@@ -38,5 +38,5 @@
   [Item("Gaussian Process Regression", "Gaussian process regression data analysis algorithm.")]
   [Creatable(CreatableAttribute.Categories.DataAnalysisRegression, Priority = 160)]
-  [StorableClass]
+  [StorableType("4aa95e9a-2f3d-4027-9b66-dc4b0f94b22e")]
   public sealed class GaussianProcessRegression : GaussianProcessBase, IStorableContent {
     public string Filename { get; set; }
Index: branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/GaussianProcessRegressionModelCreator.cs
===================================================================
--- branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/GaussianProcessRegressionModelCreator.cs	(revision 14926)
+++ branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/GaussianProcessRegressionModelCreator.cs	(revision 14927)
@@ -27,9 +27,9 @@
 using HeuristicLab.Encodings.RealVectorEncoding;
 using HeuristicLab.Parameters;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Persistence;
 using HeuristicLab.Problems.DataAnalysis;
 
 namespace HeuristicLab.Algorithms.DataAnalysis {
-  [StorableClass]
+  [StorableType("25272a52-1405-4ac3-a1ba-61f6ad0e28c2")]
   [Item(Name = "GaussianProcessRegressionModelCreator",
     Description = "Creates a Gaussian process model for regression given the data, the hyperparameters, a mean function, and a covariance function.")]
@@ -68,7 +68,5 @@
         HyperparameterGradientsParameter.ActualValue = new RealVector(model.HyperparameterGradients);
         return base.Apply();
-      }
-      catch (ArgumentException) { }
-      catch (alglib.alglibexception) { }
+      } catch (ArgumentException) { } catch (alglib.alglibexception) { }
       NegativeLogLikelihoodParameter.ActualValue = new DoubleValue(1E300);
       HyperparameterGradientsParameter.ActualValue = new RealVector(Hyperparameter.Count());
Index: branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/GaussianProcessRegressionSolution.cs
===================================================================
--- branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/GaussianProcessRegressionSolution.cs	(revision 14926)
+++ branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/GaussianProcessRegressionSolution.cs	(revision 14927)
@@ -22,5 +22,5 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Persistence;
 using HeuristicLab.Problems.DataAnalysis;
 
@@ -30,5 +30,5 @@
   /// </summary>
   [Item("GaussianProcessRegressionSolution", "Represents a Gaussian process solution for a regression problem which can be visualized in the GUI.")]
-  [StorableClass]
+  [StorableType("6ddf1034-4e65-41b7-bf6d-4415b81bdac4")]
   public sealed class GaussianProcessRegressionSolution : ConfidenceRegressionSolution, IGaussianProcessSolution {
 
Index: branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/GaussianProcessRegressionSolutionCreator.cs
===================================================================
--- branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/GaussianProcessRegressionSolutionCreator.cs	(revision 14926)
+++ branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/GaussianProcessRegressionSolutionCreator.cs	(revision 14927)
@@ -26,9 +26,9 @@
 using HeuristicLab.Optimization;
 using HeuristicLab.Parameters;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Persistence;
 using HeuristicLab.Problems.DataAnalysis;
 
 namespace HeuristicLab.Algorithms.DataAnalysis {
-  [StorableClass]
+  [StorableType("10c3a797-39c0-4a1d-9e55-db363410d4ac")]
   [Item(Name = "GaussianProcessRegressionSolutionCreator",
     Description = "Creates a Gaussian process solution from a trained model.")]
@@ -109,6 +109,6 @@
                                  "The Pearson's R² of the Gaussian process solution on the test partition.",
                                  new DoubleValue(s.TestRSquared)));
-          results.Add(new Result(NegLogPredictiveProbability, 
-                                 "The leave-one-out-cross-validation negative log predictive probability.", 
+          results.Add(new Result(NegLogPredictiveProbability,
+                                 "The leave-one-out-cross-validation negative log predictive probability.",
                                  new DoubleValue(m.NegativeLooPredictiveProbability)));
         } else {
Index: branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/MeanFunctions/MeanConst.cs
===================================================================
--- branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/MeanFunctions/MeanConst.cs	(revision 14926)
+++ branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/MeanFunctions/MeanConst.cs	(revision 14927)
@@ -27,8 +27,8 @@
 using HeuristicLab.Data;
 using HeuristicLab.Parameters;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Persistence;
 
 namespace HeuristicLab.Algorithms.DataAnalysis {
-  [StorableClass]
+  [StorableType("a70780d8-5636-470d-be60-e58eba9586de")]
   [Item(Name = "MeanConst", Description = "Constant mean function for Gaussian processes.")]
   public sealed class MeanConst : ParameterizedNamedItem, IMeanFunction {
Index: branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/MeanFunctions/MeanLinear.cs
===================================================================
--- branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/MeanFunctions/MeanLinear.cs	(revision 14926)
+++ branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/MeanFunctions/MeanLinear.cs	(revision 14927)
@@ -26,8 +26,8 @@
 using HeuristicLab.Data;
 using HeuristicLab.Parameters;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Persistence;
 
 namespace HeuristicLab.Algorithms.DataAnalysis {
-  [StorableClass]
+  [StorableType("38befee6-b589-4c9a-a936-9231315f9c2b")]
   [Item(Name = "MeanLinear", Description = "Linear mean function for Gaussian processes.")]
   public sealed class MeanLinear : ParameterizedNamedItem, IMeanFunction {
Index: branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/MeanFunctions/MeanModel.cs
===================================================================
--- branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/MeanFunctions/MeanModel.cs	(revision 14926)
+++ branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/MeanFunctions/MeanModel.cs	(revision 14927)
@@ -25,9 +25,9 @@
 using HeuristicLab.Core;
 using HeuristicLab.Parameters;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Persistence;
 using HeuristicLab.Problems.DataAnalysis;
 
 namespace HeuristicLab.Algorithms.DataAnalysis {
-  [StorableClass]
+  [StorableType("0c247c91-42bf-483d-a569-df27898c779a")]
   [Item(Name = "MeanModel", Description = "A mean function for Gaussian processes that uses a regression solution created with a different algorithm to calculate the mean.")]
   // essentially an adaptor which maps from IMeanFunction to IRegressionSolution
Index: branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/MeanFunctions/MeanProduct.cs
===================================================================
--- branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/MeanFunctions/MeanProduct.cs	(revision 14926)
+++ branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/MeanFunctions/MeanProduct.cs	(revision 14927)
@@ -24,8 +24,8 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Persistence;
 
 namespace HeuristicLab.Algorithms.DataAnalysis {
-  [StorableClass]
+  [StorableType("a6e4eb22-3de7-499f-8a8c-d4a01e87c770")]
   [Item(Name = "MeanProduct", Description = "Product of mean functions for Gaussian processes.")]
   public sealed class MeanProduct : Item, IMeanFunction {
Index: branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/MeanFunctions/MeanSum.cs
===================================================================
--- branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/MeanFunctions/MeanSum.cs	(revision 14926)
+++ branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/MeanFunctions/MeanSum.cs	(revision 14927)
@@ -24,8 +24,8 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Persistence;
 
 namespace HeuristicLab.Algorithms.DataAnalysis {
-  [StorableClass]
+  [StorableType("7c2fc647-a0f3-4645-9d65-c9da98c9d462")]
   [Item(Name = "MeanSum", Description = "Sum of mean functions for Gaussian processes.")]
   public sealed class MeanSum : Item, IMeanFunction {
Index: branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/MeanFunctions/MeanZero.cs
===================================================================
--- branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/MeanFunctions/MeanZero.cs	(revision 14926)
+++ branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/MeanFunctions/MeanZero.cs	(revision 14927)
@@ -22,8 +22,8 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Persistence;
 
 namespace HeuristicLab.Algorithms.DataAnalysis {
-  [StorableClass]
+  [StorableType("1dccc607-777a-4c51-a60e-3cab8accdb68")]
   [Item(Name = "MeanZero", Description = "Constant zero mean function for Gaussian processes.")]
   public sealed class MeanZero : Item, IMeanFunction {
Index: branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GradientBoostedTrees/GradientBoostedTreesAlgorithm.cs
===================================================================
--- branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GradientBoostedTrees/GradientBoostedTreesAlgorithm.cs	(revision 14926)
+++ branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GradientBoostedTrees/GradientBoostedTreesAlgorithm.cs	(revision 14927)
@@ -29,5 +29,5 @@
 using HeuristicLab.Optimization;
 using HeuristicLab.Parameters;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Persistence;
 using HeuristicLab.PluginInfrastructure;
 using HeuristicLab.Problems.DataAnalysis;
@@ -35,5 +35,5 @@
 namespace HeuristicLab.Algorithms.DataAnalysis {
   [Item("Gradient Boosted Trees (GBT)", "Gradient boosted trees algorithm. Specific implementation of gradient boosting for regression trees. Friedman, J. \"Greedy Function Approximation: A Gradient Boosting Machine\", IMS 1999 Reitz Lecture.")]
-  [StorableClass]
+  [StorableType("86b7e34d-60ff-4abf-9cbe-d881b456d480")]
   [Creatable(CreatableAttribute.Categories.DataAnalysisRegression, Priority = 125)]
   public class GradientBoostedTreesAlgorithm : FixedDataAnalysisAlgorithm<IRegressionProblem> {
Index: branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GradientBoostedTrees/GradientBoostedTreesModel.cs
===================================================================
--- branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GradientBoostedTrees/GradientBoostedTreesModel.cs	(revision 14926)
+++ branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GradientBoostedTrees/GradientBoostedTreesModel.cs	(revision 14927)
@@ -26,9 +26,9 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Persistence;
 using HeuristicLab.Problems.DataAnalysis;
 
 namespace HeuristicLab.Algorithms.DataAnalysis {
-  [StorableClass]
+  [StorableType("9f7e367c-6010-44a6-8e0e-dfc9881725d4")]
   [Item("Gradient boosted tree model", "")]
   // this is essentially a collection of weighted regression models
Index: branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GradientBoostedTrees/GradientBoostedTreesModelSurrogate.cs
===================================================================
--- branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GradientBoostedTrees/GradientBoostedTreesModelSurrogate.cs	(revision 14926)
+++ branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GradientBoostedTrees/GradientBoostedTreesModelSurrogate.cs	(revision 14927)
@@ -27,9 +27,9 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Persistence;
 using HeuristicLab.Problems.DataAnalysis;
 
 namespace HeuristicLab.Algorithms.DataAnalysis {
-  [StorableClass]
+  [StorableType("4d807e5e-3504-4e49-a3e7-03833144bbc6")]
   // this class is used as a surrogate for persistence of an actual GBT model 
   // since the actual GBT model would be very large when persisted we only store all necessary information to
Index: branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GradientBoostedTrees/GradientBoostedTreesSolution.cs
===================================================================
--- branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GradientBoostedTrees/GradientBoostedTreesSolution.cs	(revision 14926)
+++ branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GradientBoostedTrees/GradientBoostedTreesSolution.cs	(revision 14927)
@@ -21,9 +21,9 @@
 
 using HeuristicLab.Common;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Persistence;
 using HeuristicLab.Problems.DataAnalysis;
 
 namespace HeuristicLab.Algorithms.DataAnalysis {
-  [StorableClass]
+  [StorableType("2705ae1c-1dd8-4d3d-94fc-48b7fbebcc16")]
   public sealed class GradientBoostedTreesSolution : RegressionSolution {
     public new IGradientBoostedTreesModel Model {
Index: branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GradientBoostedTrees/IGradientBoostedTreesModel.cs
===================================================================
--- branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GradientBoostedTrees/IGradientBoostedTreesModel.cs	(revision 14926)
+++ branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GradientBoostedTrees/IGradientBoostedTreesModel.cs	(revision 14927)
@@ -26,5 +26,5 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Persistence;
 using HeuristicLab.Problems.DataAnalysis;
 
Index: branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GradientBoostedTrees/LossFunctions/AbsoluteErrorLoss.cs
===================================================================
--- branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GradientBoostedTrees/LossFunctions/AbsoluteErrorLoss.cs	(revision 14926)
+++ branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GradientBoostedTrees/LossFunctions/AbsoluteErrorLoss.cs	(revision 14927)
@@ -25,9 +25,9 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Persistence;
 
 namespace HeuristicLab.Algorithms.DataAnalysis {
   // loss function for the weighted absolute error
-  [StorableClass]
+  [StorableType("14d93807-88e6-4485-bd34-068ea19e6d89")]
   [Item("Absolute error loss", "")]
   public sealed class AbsoluteErrorLoss : Item, ILossFunction {
Index: branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GradientBoostedTrees/LossFunctions/LogisticRegressionLoss.cs
===================================================================
--- branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GradientBoostedTrees/LossFunctions/LogisticRegressionLoss.cs	(revision 14926)
+++ branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GradientBoostedTrees/LossFunctions/LogisticRegressionLoss.cs	(revision 14927)
@@ -27,9 +27,9 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Persistence;
 
 namespace HeuristicLab.Algorithms.DataAnalysis {
   // Greedy Function Approximation: A Gradient Boosting Machine (page 9) 
-  [StorableClass]
+  [StorableType("aa30e97c-113e-415d-bc34-ec23b5a59918")]
   [Item("Logistic regression loss", "")]
   public sealed class LogisticRegressionLoss : Item, ILossFunction {
Index: branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GradientBoostedTrees/LossFunctions/QuantileRegressionLoss.cs
===================================================================
--- branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GradientBoostedTrees/LossFunctions/QuantileRegressionLoss.cs	(revision 14926)
+++ branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GradientBoostedTrees/LossFunctions/QuantileRegressionLoss.cs	(revision 14927)
@@ -27,10 +27,10 @@
 using HeuristicLab.Data;
 using HeuristicLab.Parameters;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Persistence;
 
 namespace HeuristicLab.Algorithms.DataAnalysis {
   // loss function for quantile regression
   // Generalized Boosted Models - A Guide To The gbm Package, Greg Ridgeway, August 2007, page 11 
-  [StorableClass]
+  [StorableType("85e4d0c6-33fe-407d-b98e-bd90c4e14a36")]
   [Item("QuantileRegressionloss", "Loss function for quantile regression")]
   public sealed class QuantileRegressionLoss : ParameterizedNamedItem, ILossFunction {
Index: branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GradientBoostedTrees/LossFunctions/RelativeErrorLoss.cs
===================================================================
--- branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GradientBoostedTrees/LossFunctions/RelativeErrorLoss.cs	(revision 14926)
+++ branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GradientBoostedTrees/LossFunctions/RelativeErrorLoss.cs	(revision 14927)
@@ -27,9 +27,9 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Persistence;
 
 namespace HeuristicLab.Algorithms.DataAnalysis {
   // relative error loss is a special case of weighted absolute error loss with weights = (1/target)
-  [StorableClass]
+  [StorableType("748e85f8-5ef2-4f4e-ab33-8096fa7d1b61")]
   [Item("Relative error loss", "")]
   public sealed class RelativeErrorLoss : Item, ILossFunction {
Index: branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GradientBoostedTrees/LossFunctions/SquaredErrorLoss.cs
===================================================================
--- branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GradientBoostedTrees/LossFunctions/SquaredErrorLoss.cs	(revision 14926)
+++ branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GradientBoostedTrees/LossFunctions/SquaredErrorLoss.cs	(revision 14927)
@@ -26,8 +26,8 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Persistence;
 
 namespace HeuristicLab.Algorithms.DataAnalysis {
-  [StorableClass]
+  [StorableType("cf22c7c0-c261-4aa2-a62b-f2c6e8880cd0")]
   [Item("Squared error loss", "")]
   public sealed class SquaredErrorLoss : Item, ILossFunction {
Index: branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GradientBoostedTrees/RegressionTreeModel.cs
===================================================================
--- branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GradientBoostedTrees/RegressionTreeModel.cs	(revision 14926)
+++ branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GradientBoostedTrees/RegressionTreeModel.cs	(revision 14927)
@@ -29,5 +29,5 @@
 using HeuristicLab.Core;
 using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Persistence;
 using HeuristicLab.Problems.DataAnalysis;
 using HeuristicLab.Problems.DataAnalysis.Symbolic;
@@ -35,5 +35,5 @@
 
 namespace HeuristicLab.Algorithms.DataAnalysis {
-  [StorableClass]
+  [StorableType("8c24e829-c2b0-4add-8c04-b18353712590")]
   [Item("RegressionTreeModel", "Represents a decision tree for regression.")]
   public sealed class RegressionTreeModel : RegressionModel {
Index: branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/KernelRidgeRegression/KernelFunctions/CicularKernel.cs
===================================================================
--- branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/KernelRidgeRegression/KernelFunctions/CicularKernel.cs	(revision 14926)
+++ branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/KernelRidgeRegression/KernelFunctions/CicularKernel.cs	(revision 14927)
@@ -23,8 +23,8 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Persistence;
 
 namespace HeuristicLab.Algorithms.DataAnalysis.KernelRidgeRegression {
-  [StorableClass]
+  [StorableType("1fd9295f-e118-42b2-9a6d-63449f2a3d3c")]
   [Item("CircularKernel", "A circular kernel function 2*pi*(acos(-d)-d*(1-d²)^(0.5)) where n = ||x-c|| and d = n/beta \n  As described in http://crsouza.com/2010/03/17/kernel-functions-for-machine-learning-applications/")]
   public class CircularKernel : KernelBase {
Index: branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/KernelRidgeRegression/KernelFunctions/GaussianKernel.cs
===================================================================
--- branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/KernelRidgeRegression/KernelFunctions/GaussianKernel.cs	(revision 14926)
+++ branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/KernelRidgeRegression/KernelFunctions/GaussianKernel.cs	(revision 14927)
@@ -25,8 +25,8 @@
 using HeuristicLab.Core;
 
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Persistence;
 
 namespace HeuristicLab.Algorithms.DataAnalysis.KernelRidgeRegression {
-  [StorableClass]
+  [StorableType("6ad73da5-e042-4fe5-8b10-414a07d0deb7")]
   [Item("GaussianKernel", "A kernel function that uses Gaussian function exp(-n²/beta²). As described in http://crsouza.com/2010/03/17/kernel-functions-for-machine-learning-applications/")]
   public class GaussianKernel : KernelBase {
Index: branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/KernelRidgeRegression/KernelFunctions/InverseMultiquadraticKernel.cs
===================================================================
--- branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/KernelRidgeRegression/KernelFunctions/InverseMultiquadraticKernel.cs	(revision 14926)
+++ branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/KernelRidgeRegression/KernelFunctions/InverseMultiquadraticKernel.cs	(revision 14927)
@@ -23,8 +23,8 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Persistence;
 
 namespace HeuristicLab.Algorithms.DataAnalysis.KernelRidgeRegression {
-  [StorableClass]
+  [StorableType("ecd37191-f1e5-48b8-a25b-874563a6afd6")]
   [Item("InverseMultiquadraticKernel", "A kernel function that uses the inverse multi-quadratic function  1 / sqrt(1+||x-c||²/beta²). Similar to http://crsouza.com/2010/03/17/kernel-functions-for-machine-learning-applications/ with beta as a scaling factor.")]
   public class InverseMultiquadraticKernel : KernelBase {
Index: branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/KernelRidgeRegression/KernelFunctions/KernelBase.cs
===================================================================
--- branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/KernelRidgeRegression/KernelFunctions/KernelBase.cs	(revision 14926)
+++ branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/KernelRidgeRegression/KernelFunctions/KernelBase.cs	(revision 14927)
@@ -26,8 +26,8 @@
 using HeuristicLab.Core;
 using HeuristicLab.Parameters;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Persistence;
 
 namespace HeuristicLab.Algorithms.DataAnalysis.KernelRidgeRegression {
-  [StorableClass]
+  [StorableType("c6e3751a-1eab-4068-af73-e39f52cded26")]
   public abstract class KernelBase : ParameterizedNamedItem, IKernel {
 
Index: branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/KernelRidgeRegression/KernelFunctions/MultiquadraticKernel.cs
===================================================================
--- branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/KernelRidgeRegression/KernelFunctions/MultiquadraticKernel.cs	(revision 14926)
+++ branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/KernelRidgeRegression/KernelFunctions/MultiquadraticKernel.cs	(revision 14927)
@@ -23,8 +23,8 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Persistence;
 
 namespace HeuristicLab.Algorithms.DataAnalysis.KernelRidgeRegression {
-  [StorableClass]
+  [StorableType("65ab934e-630c-4c70-8767-2ea1df20abd1")]
   // conditionally positive definite. (need to add polynomials) see http://num.math.uni-goettingen.de/schaback/teaching/sc.pdf 
   [Item("MultiquadraticKernel", "A kernel function that uses the multi-quadratic function sqrt(1+||x-c||²/beta²). Similar to http://crsouza.com/2010/03/17/kernel-functions-for-machine-learning-applications/ with beta as a scaling factor.")]
Index: branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/KernelRidgeRegression/KernelFunctions/PolysplineKernel.cs
===================================================================
--- branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/KernelRidgeRegression/KernelFunctions/PolysplineKernel.cs	(revision 14926)
+++ branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/KernelRidgeRegression/KernelFunctions/PolysplineKernel.cs	(revision 14927)
@@ -25,8 +25,8 @@
 using HeuristicLab.Data;
 using HeuristicLab.Parameters;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Persistence;
 
 namespace HeuristicLab.Algorithms.DataAnalysis.KernelRidgeRegression {
-  [StorableClass]
+  [StorableType("424d1640-3752-4e6e-a749-58ddf0332bbf")]
   // conditionally positive definite. (need to add polynomials) see http://num.math.uni-goettingen.de/schaback/teaching/sc.pdf 
   [Item("PolysplineKernel", "A kernel function that uses the polyharmonic function (||x-c||/Beta)^Degree as given in http://num.math.uni-goettingen.de/schaback/teaching/sc.pdf with beta as a scaling parameters.")]
Index: branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/KernelRidgeRegression/KernelFunctions/ThinPlatePolysplineKernel.cs
===================================================================
--- branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/KernelRidgeRegression/KernelFunctions/ThinPlatePolysplineKernel.cs	(revision 14926)
+++ branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/KernelRidgeRegression/KernelFunctions/ThinPlatePolysplineKernel.cs	(revision 14927)
@@ -25,8 +25,8 @@
 using HeuristicLab.Data;
 using HeuristicLab.Parameters;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Persistence;
 
 namespace HeuristicLab.Algorithms.DataAnalysis.KernelRidgeRegression {
-  [StorableClass]
+  [StorableType("448226e7-bdac-4269-a306-e8fb398cae33")]
   // conditionally positive definite. (need to add polynomials) see http://num.math.uni-goettingen.de/schaback/teaching/sc.pdf 
   [Item("ThinPlatePolysplineKernel", "A kernel function that uses the ThinPlatePolyspline function (||x-c||/Beta)^(Degree)*log(||x-c||/Beta) as described in \"Thin-Plate Spline Radial Basis Function Scheme for Advection-Diffusion Problems\" with beta as a scaling parameter.")]
Index: branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/KernelRidgeRegression/KernelRidgeRegression.cs
===================================================================
--- branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/KernelRidgeRegression/KernelRidgeRegression.cs	(revision 14926)
+++ branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/KernelRidgeRegression/KernelRidgeRegression.cs	(revision 14927)
@@ -28,5 +28,5 @@
 using HeuristicLab.Optimization;
 using HeuristicLab.Parameters;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Persistence;
 using HeuristicLab.Problems.DataAnalysis;
 
@@ -34,5 +34,5 @@
   [Item("Kernel Ridge Regression", "Kernelized ridge regression e.g. for radial basis function (RBF) regression.")]
   [Creatable(CreatableAttribute.Categories.DataAnalysisRegression, Priority = 100)]
-  [StorableClass]
+  [StorableType("ea532dbe-1c68-4fd8-84f2-0f2ca8a8cd27")]
   public sealed class KernelRidgeRegression : BasicAlgorithm {
     private const string SolutionResultName = "Kernel ridge regression solution";
Index: branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/KernelRidgeRegression/KernelRidgeRegressionModel.cs
===================================================================
--- branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/KernelRidgeRegression/KernelRidgeRegressionModel.cs	(revision 14926)
+++ branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/KernelRidgeRegression/KernelRidgeRegressionModel.cs	(revision 14927)
@@ -25,9 +25,9 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Persistence;
 using HeuristicLab.Problems.DataAnalysis;
 
 namespace HeuristicLab.Algorithms.DataAnalysis.KernelRidgeRegression {
-  [StorableClass]
+  [StorableType("c3f8bc07-a96b-4555-8f33-99cc24923e9e")]
   [Item("KernelRidgeRegressionModel", "A kernel ridge regression model")]
   public sealed class KernelRidgeRegressionModel : RegressionModel {
Index: branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/Linear/LinearDiscriminantAnalysis.cs
===================================================================
--- branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/Linear/LinearDiscriminantAnalysis.cs	(revision 14926)
+++ branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/Linear/LinearDiscriminantAnalysis.cs	(revision 14927)
@@ -28,5 +28,5 @@
 using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
 using HeuristicLab.Optimization;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Persistence;
 using HeuristicLab.Problems.DataAnalysis;
 using HeuristicLab.Problems.DataAnalysis.Symbolic;
@@ -39,5 +39,5 @@
   [Item("Linear Discriminant Analysis (LDA)", "Linear discriminant analysis classification algorithm (wrapper for ALGLIB).")]
   [Creatable(CreatableAttribute.Categories.DataAnalysisClassification, Priority = 100)]
-  [StorableClass]
+  [StorableType("4d8f9d7e-490f-40f8-ba8f-ac26a6048027")]
   public sealed class LinearDiscriminantAnalysis : FixedDataAnalysisAlgorithm<IClassificationProblem> {
     private const string LinearDiscriminantAnalysisSolutionResultName = "Linear discriminant analysis solution";
Index: branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/Linear/LinearRegression.cs
===================================================================
--- branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/Linear/LinearRegression.cs	(revision 14926)
+++ branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/Linear/LinearRegression.cs	(revision 14927)
@@ -28,5 +28,5 @@
 using HeuristicLab.Data;
 using HeuristicLab.Optimization;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Persistence;
 using HeuristicLab.Problems.DataAnalysis;
 using HeuristicLab.Problems.DataAnalysis.Symbolic;
@@ -39,5 +39,5 @@
   [Item("Linear Regression (LR)", "Linear regression data analysis algorithm (wrapper for ALGLIB).")]
   [Creatable(CreatableAttribute.Categories.DataAnalysisRegression, Priority = 100)]
-  [StorableClass]
+  [StorableType("7c7ea61f-583d-4edc-bd89-485ef0fed1de")]
   public sealed class LinearRegression : FixedDataAnalysisAlgorithm<IRegressionProblem> {
     private const string LinearRegressionModelResultName = "Linear regression solution";
@@ -100,7 +100,7 @@
       int nVarCoeff = doubleVariables.Count();
       var tree = LinearModelToTreeConverter.CreateTree(factorVariables, coefficients.Take(nFactorCoeff).ToArray(),
-        doubleVariables.ToArray(), coefficients.Skip(nFactorCoeff).Take(nVarCoeff).ToArray(), 
+        doubleVariables.ToArray(), coefficients.Skip(nFactorCoeff).Take(nVarCoeff).ToArray(),
         @const: coefficients[nFeatures]);
-      
+
       SymbolicRegressionSolution solution = new SymbolicRegressionSolution(new SymbolicRegressionModel(problemData.TargetVariable, tree, new SymbolicDataAnalysisExpressionTreeLinearInterpreter()), (IRegressionProblemData)problemData.Clone());
       solution.Model.Name = "Linear Regression Model";
Index: branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/Linear/MultinomialLogitClassification.cs
===================================================================
--- branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/Linear/MultinomialLogitClassification.cs	(revision 14926)
+++ branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/Linear/MultinomialLogitClassification.cs	(revision 14927)
@@ -28,5 +28,5 @@
 using HeuristicLab.Data;
 using HeuristicLab.Optimization;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Persistence;
 using HeuristicLab.Problems.DataAnalysis;
 
@@ -37,5 +37,5 @@
   [Item("Multinomial Logit Classification (MNL)", "Multinomial logit classification data analysis algorithm (wrapper for ALGLIB).")]
   [Creatable(CreatableAttribute.Categories.DataAnalysisClassification, Priority = 180)]
-  [StorableClass]
+  [StorableType("3db64b58-74ee-4c82-9047-8f324a0ce512")]
   public sealed class MultiNomialLogitClassification : FixedDataAnalysisAlgorithm<IClassificationProblem> {
     private const string LogitClassificationModelResultName = "Logit classification solution";
Index: branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/Linear/MultinomialLogitClassificationSolution.cs
===================================================================
--- branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/Linear/MultinomialLogitClassificationSolution.cs	(revision 14926)
+++ branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/Linear/MultinomialLogitClassificationSolution.cs	(revision 14927)
@@ -22,5 +22,5 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Persistence;
 using HeuristicLab.Problems.DataAnalysis;
 
@@ -30,5 +30,5 @@
   /// </summary>
   [Item("Multinomial Logit Classification Solution", "Represents a multinomial logit solution for a classification problem which can be visualized in the GUI.")]
-  [StorableClass]
+  [StorableType("08aa7db8-2114-477f-bca9-e3ce915109b0")]
   public sealed class MultinomialLogitClassificationSolution : ClassificationSolution {
 
Index: branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/Linear/MultinomialLogitModel.cs
===================================================================
--- branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/Linear/MultinomialLogitModel.cs	(revision 14926)
+++ branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/Linear/MultinomialLogitModel.cs	(revision 14927)
@@ -25,5 +25,5 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Persistence;
 using HeuristicLab.Problems.DataAnalysis;
 
@@ -32,5 +32,5 @@
   /// Represents a multinomial logit model for classification
   /// </summary>
-  [StorableClass]
+  [StorableType("df634319-7c96-4c2d-ad5d-cb098564f609")]
   [Item("Multinomial Logit Model", "Represents a multinomial logit model for classification.")]
   public sealed class MultinomialLogitModel : ClassificationModel {
Index: branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/Linear/Scaling.cs
===================================================================
--- branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/Linear/Scaling.cs	(revision 14926)
+++ branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/Linear/Scaling.cs	(revision 14927)
@@ -25,10 +25,10 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Persistence;
 using HeuristicLab.Problems.DataAnalysis;
 
 namespace HeuristicLab.Algorithms.DataAnalysis {
   [Obsolete("Use transformation classes in Problems.DataAnalysis instead")]
-  [StorableClass]
+  [StorableType("33a29a7a-153b-4b43-9235-ab59f8dfb821")]
   [Item(Name = "Scaling", Description = "Contains information about scaling of variables for data-analysis algorithms.")]
   public class Scaling : Item {
Index: branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/MctsSymbolicRegression/Disassembler.cs
===================================================================
--- branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/MctsSymbolicRegression/Disassembler.cs	(revision 14926)
+++ branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/MctsSymbolicRegression/Disassembler.cs	(revision 14927)
@@ -36,13 +36,12 @@
           case (byte)OpCodes.LoadConst0: sb.Append(" 0 "); break;
           case (byte)OpCodes.LoadParamN: sb.AppendFormat(" {0:N3} ", consts[++nextParamIdx]); break;
-          case (byte)OpCodes.LoadVar:
-          {
+          case (byte)OpCodes.LoadVar: {
               short arg = (short)((code[pc] << 8) | code[pc + 1]);
               pc += 2;
-            sb.AppendFormat(" var{0} ", arg); break;
-          }
+              sb.AppendFormat(" var{0} ", arg); break;
+            }
           case (byte)OpCodes.Exp: sb.Append(" exp "); break;
           case (byte)OpCodes.Log: sb.Append(" log "); break;
-          case (byte)OpCodes.Inv: sb.Append(" inv "); break;          
+          case (byte)OpCodes.Inv: sb.Append(" inv "); break;
         }
       }
Index: branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/MctsSymbolicRegression/MctsSymbolicRegressionAlgorithm.cs
===================================================================
--- branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/MctsSymbolicRegression/MctsSymbolicRegressionAlgorithm.cs	(revision 14926)
+++ branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/MctsSymbolicRegression/MctsSymbolicRegressionAlgorithm.cs	(revision 14927)
@@ -31,10 +31,10 @@
 using HeuristicLab.Optimization;
 using HeuristicLab.Parameters;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Persistence;
 using HeuristicLab.Problems.DataAnalysis;
 
 namespace HeuristicLab.Algorithms.DataAnalysis.MctsSymbolicRegression {
   [Item("MCTS Symbolic Regression", "Monte carlo tree search for symbolic regression. Useful mainly as a base learner in gradient boosting.")]
-  [StorableClass]
+  [StorableType("edeba9a4-a1c5-44d5-84f8-fb57d6770144")]
   [Creatable(CreatableAttribute.Categories.DataAnalysisRegression, Priority = 250)]
   public class MctsSymbolicRegressionAlgorithm : FixedDataAnalysisAlgorithm<IRegressionProblem> {
Index: branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/MctsSymbolicRegression/Policies/EpsGreedy.cs
===================================================================
--- branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/MctsSymbolicRegression/Policies/EpsGreedy.cs	(revision 14926)
+++ branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/MctsSymbolicRegression/Policies/EpsGreedy.cs	(revision 14927)
@@ -9,8 +9,8 @@
 using HeuristicLab.Data;
 using HeuristicLab.Parameters;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Persistence;
 
 namespace HeuristicLab.Algorithms.DataAnalysis.MctsSymbolicRegression.Policies {
-  [StorableClass]
+  [StorableType("1a6465df-509f-4977-a9fc-fcf4e420fb5d")]
   [Item("EpsilonGreedy", "Epsilon greedy policy with parameter eps to balance between exploitation and exploration")]
   public class EpsilonGreedy : PolicyBase {
Index: branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/MctsSymbolicRegression/Policies/PolicyBase.cs
===================================================================
--- branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/MctsSymbolicRegression/Policies/PolicyBase.cs	(revision 14926)
+++ branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/MctsSymbolicRegression/Policies/PolicyBase.cs	(revision 14927)
@@ -7,8 +7,8 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Persistence;
 
 namespace HeuristicLab.Algorithms.DataAnalysis.MctsSymbolicRegression.Policies {
-  [StorableClass]
+  [StorableType("d2a06cc9-6b72-47aa-9d41-4aa814d002d9")]
   public abstract class PolicyBase : Item, IParameterizedItem, IPolicy {
     [Storable]
Index: branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/MctsSymbolicRegression/Policies/Ucb.cs
===================================================================
--- branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/MctsSymbolicRegression/Policies/Ucb.cs	(revision 14926)
+++ branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/MctsSymbolicRegression/Policies/Ucb.cs	(revision 14927)
@@ -9,8 +9,8 @@
 using HeuristicLab.Data;
 using HeuristicLab.Parameters;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Persistence;
 
 namespace HeuristicLab.Algorithms.DataAnalysis.MctsSymbolicRegression.Policies {
-  [StorableClass]
+  [StorableType("70d954bb-7e36-40d2-a1e9-17f955f02ed5")]
   [Item("Ucb Policy", "Ucb with parameter c to balance between exploitation and exploration")]
   public class Ucb : PolicyBase {
Index: branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/MctsSymbolicRegression/Policies/UcbTuned.cs
===================================================================
--- branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/MctsSymbolicRegression/Policies/UcbTuned.cs	(revision 14926)
+++ branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/MctsSymbolicRegression/Policies/UcbTuned.cs	(revision 14927)
@@ -9,8 +9,8 @@
 using HeuristicLab.Data;
 using HeuristicLab.Parameters;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Persistence;
 
 namespace HeuristicLab.Algorithms.DataAnalysis.MctsSymbolicRegression.Policies {
-  [StorableClass]
+  [StorableType("20805399-3b19-4a46-befa-8600bdc566eb")]
   [Item("UcbTuned Policy", "UcbTuned is similar to Ucb but tracks empirical variance. Use parameter c to balance between exploitation and exploration")]
   public class UcbTuned : PolicyBase {
Index: branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/Nca/Initialization/LdaInitializer.cs
===================================================================
--- branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/Nca/Initialization/LdaInitializer.cs	(revision 14926)
+++ branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/Nca/Initialization/LdaInitializer.cs	(revision 14927)
@@ -23,10 +23,10 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Persistence;
 using HeuristicLab.Problems.DataAnalysis;
 
 namespace HeuristicLab.Algorithms.DataAnalysis {
   [Item("LDA", "Initializes the matrix by performing a linear discriminant analysis.")]
-  [StorableClass]
+  [StorableType("1dd6ed9b-e651-4117-bd19-970af453f0aa")]
   public class LdaInitializer : NcaInitializer {
 
Index: branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/Nca/Initialization/NcaInitializer.cs
===================================================================
--- branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/Nca/Initialization/NcaInitializer.cs	(revision 14926)
+++ branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/Nca/Initialization/NcaInitializer.cs	(revision 14927)
@@ -26,10 +26,10 @@
 using HeuristicLab.Operators;
 using HeuristicLab.Parameters;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Persistence;
 using HeuristicLab.Problems.DataAnalysis;
 
 namespace HeuristicLab.Algorithms.DataAnalysis {
   [Item("NcaInitializer", "Base class for initializers for NCA.")]
-  [StorableClass]
+  [StorableType("362eedbd-cabb-44b1-8c4d-3624d14c4fff")]
   public abstract class NcaInitializer : SingleSuccessorOperator, INcaInitializer {
 
Index: branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/Nca/Initialization/PcaInitializer.cs
===================================================================
--- branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/Nca/Initialization/PcaInitializer.cs	(revision 14926)
+++ branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/Nca/Initialization/PcaInitializer.cs	(revision 14927)
@@ -23,10 +23,10 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Persistence;
 using HeuristicLab.Problems.DataAnalysis;
 
 namespace HeuristicLab.Algorithms.DataAnalysis {
   [Item("PCA", "Initializes the matrix by performing a principal components analysis.")]
-  [StorableClass]
+  [StorableType("c23dade6-2f4d-4ff1-8a85-1e006bd0d707")]
   public sealed class PcaInitializer : NcaInitializer {
 
Index: branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/Nca/Initialization/RandomInitializer.cs
===================================================================
--- branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/Nca/Initialization/RandomInitializer.cs	(revision 14926)
+++ branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/Nca/Initialization/RandomInitializer.cs	(revision 14927)
@@ -25,10 +25,10 @@
 using HeuristicLab.Optimization;
 using HeuristicLab.Parameters;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Persistence;
 using HeuristicLab.Problems.DataAnalysis;
 
 namespace HeuristicLab.Algorithms.DataAnalysis {
   [Item("Random", "Initializes the matrix randomly.")]
-  [StorableClass]
+  [StorableType("19693b0f-cf3e-4862-87b2-7c6d79156b29")]
   public sealed class RandomInitializer : NcaInitializer, IStochasticOperator {
     public ILookupParameter<IRandom> RandomParameter {
Index: branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/Nca/ModelCreation/NcaModelCreator.cs
===================================================================
--- branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/Nca/ModelCreation/NcaModelCreator.cs	(revision 14926)
+++ branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/Nca/ModelCreation/NcaModelCreator.cs	(revision 14927)
@@ -27,10 +27,10 @@
 using HeuristicLab.Operators;
 using HeuristicLab.Parameters;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Persistence;
 using HeuristicLab.Problems.DataAnalysis;
 
 namespace HeuristicLab.Algorithms.DataAnalysis {
   [Item("NcaModelCreator", "Creates an NCA model with a given matrix.")]
-  [StorableClass]
+  [StorableType("f92ef388-cba8-4729-97cb-141bff1f2c47")]
   public class NcaModelCreator : SingleSuccessorOperator, INcaModelCreator {
 
Index: branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/Nca/NcaAlgorithm.cs
===================================================================
--- branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/Nca/NcaAlgorithm.cs	(revision 14926)
+++ branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/Nca/NcaAlgorithm.cs	(revision 14927)
@@ -29,5 +29,5 @@
 using HeuristicLab.Optimization;
 using HeuristicLab.Parameters;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Persistence;
 using HeuristicLab.PluginInfrastructure;
 using HeuristicLab.Problems.DataAnalysis;
@@ -44,5 +44,5 @@
 Regularized Neighborhood Component Analysis. Lecture Notes in Computer Science, 4522. pp. 253-262.")]
   [Creatable(CreatableAttribute.Categories.DataAnalysisClassification, Priority = 170)]
-  [StorableClass]
+  [StorableType("eba71fdc-d88f-4f33-84dc-515dfd55a602")]
   public sealed class NcaAlgorithm : EngineAlgorithm {
     #region Parameter Names
Index: branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/Nca/NcaClassificationSolution.cs
===================================================================
--- branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/Nca/NcaClassificationSolution.cs	(revision 14926)
+++ branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/Nca/NcaClassificationSolution.cs	(revision 14927)
@@ -22,10 +22,10 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Persistence;
 using HeuristicLab.Problems.DataAnalysis;
 
 namespace HeuristicLab.Algorithms.DataAnalysis {
   [Item("NCA Classification Solution", "")]
-  [StorableClass]
+  [StorableType("fec32566-7f94-4eea-ac06-68f5e5249d58")]
   public class NcaClassificationSolution : ClassificationSolution, INcaClassificationSolution {
 
Index: branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/Nca/NcaGradientCalculator.cs
===================================================================
--- branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/Nca/NcaGradientCalculator.cs	(revision 14926)
+++ branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/Nca/NcaGradientCalculator.cs	(revision 14927)
@@ -30,10 +30,10 @@
 using HeuristicLab.Optimization;
 using HeuristicLab.Parameters;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Persistence;
 using HeuristicLab.Problems.DataAnalysis;
 
 namespace HeuristicLab.Algorithms.DataAnalysis {
   [Item("NcaGradientCalculator", "Calculates the quality and gradient of a certain NCA matrix.")]
-  [StorableClass]
+  [StorableType("44d39323-32c5-40e8-8074-9eea2075920d")]
   public class NcaGradientCalculator : SingleSuccessorOperator, ISingleObjectiveOperator {
 
Index: branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/Nca/NcaModel.cs
===================================================================
--- branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/Nca/NcaModel.cs	(revision 14926)
+++ branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/Nca/NcaModel.cs	(revision 14927)
@@ -24,10 +24,10 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Persistence;
 using HeuristicLab.Problems.DataAnalysis;
 
 namespace HeuristicLab.Algorithms.DataAnalysis {
   [Item("NCA Model", "")]
-  [StorableClass]
+  [StorableType("c7d5332f-8405-46dc-8516-72156dd56396")]
   public class NcaModel : ClassificationModel, INcaModel {
     public override IEnumerable<string> VariablesUsedForPrediction {
Index: branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/Nca/SolutionCreation/NcaSolutionCreator.cs
===================================================================
--- branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/Nca/SolutionCreation/NcaSolutionCreator.cs	(revision 14926)
+++ branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/Nca/SolutionCreation/NcaSolutionCreator.cs	(revision 14927)
@@ -26,10 +26,10 @@
 using HeuristicLab.Optimization;
 using HeuristicLab.Parameters;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Persistence;
 using HeuristicLab.Problems.DataAnalysis;
 
 namespace HeuristicLab.Algorithms.DataAnalysis {
   [Item("NcaSolutionCreator", "Creates an NCA solution with a given model and some given data.")]
-  [StorableClass]
+  [StorableType("0760a066-f417-4a78-a5ed-99b7d43ec14e")]
   public class NcaSolutionCreator : SingleSuccessorOperator, INcaSolutionCreator {
 
Index: branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/NearestNeighbour/NearestNeighbourClassification.cs
===================================================================
--- branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/NearestNeighbour/NearestNeighbourClassification.cs	(revision 14926)
+++ branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/NearestNeighbour/NearestNeighbourClassification.cs	(revision 14927)
@@ -28,5 +28,5 @@
 using HeuristicLab.Optimization;
 using HeuristicLab.Parameters;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Persistence;
 using HeuristicLab.Problems.DataAnalysis;
 
@@ -37,5 +37,5 @@
   [Item("Nearest Neighbour Classification (kNN)", "Nearest neighbour classification data analysis algorithm (wrapper for ALGLIB).")]
   [Creatable(CreatableAttribute.Categories.DataAnalysisClassification, Priority = 150)]
-  [StorableClass]
+  [StorableType("014b7587-cf2f-4e43-aeb7-de52ddded552")]
   public sealed class NearestNeighbourClassification : FixedDataAnalysisAlgorithm<IClassificationProblem> {
     private const string KParameterName = "K";
Index: branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/NearestNeighbour/NearestNeighbourClassificationSolution.cs
===================================================================
--- branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/NearestNeighbour/NearestNeighbourClassificationSolution.cs	(revision 14926)
+++ branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/NearestNeighbour/NearestNeighbourClassificationSolution.cs	(revision 14927)
@@ -22,5 +22,5 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Persistence;
 using HeuristicLab.Problems.DataAnalysis;
 
@@ -30,5 +30,5 @@
   /// </summary>
   [Item("NearestNeighbourClassificationSolution", "Represents a nearest neighbour solution for a classification problem which can be visualized in the GUI.")]
-  [StorableClass]
+  [StorableType("6f2db1ea-37e6-4d22-a79b-a982cad00103")]
   public sealed class NearestNeighbourClassificationSolution : ClassificationSolution, INearestNeighbourClassificationSolution {
 
Index: branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/NearestNeighbour/NearestNeighbourModel.cs
===================================================================
--- branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/NearestNeighbour/NearestNeighbourModel.cs	(revision 14926)
+++ branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/NearestNeighbour/NearestNeighbourModel.cs	(revision 14927)
@@ -25,5 +25,5 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Persistence;
 using HeuristicLab.Problems.DataAnalysis;
 
@@ -32,5 +32,5 @@
   /// Represents a nearest neighbour model for regression and classification
   /// </summary>
-  [StorableClass]
+  [StorableType("da958292-162f-4292-8d09-66e9838a24ed")]
   [Item("NearestNeighbourModel", "Represents a nearest neighbour model for regression and classification.")]
   public sealed class NearestNeighbourModel : ClassificationModel, INearestNeighbourModel {
Index: branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/NearestNeighbour/NearestNeighbourRegression.cs
===================================================================
--- branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/NearestNeighbour/NearestNeighbourRegression.cs	(revision 14926)
+++ branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/NearestNeighbour/NearestNeighbourRegression.cs	(revision 14927)
@@ -27,5 +27,5 @@
 using HeuristicLab.Optimization;
 using HeuristicLab.Parameters;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Persistence;
 using HeuristicLab.Problems.DataAnalysis;
 
@@ -36,5 +36,5 @@
   [Item("Nearest Neighbour Regression (kNN)", "Nearest neighbour regression data analysis algorithm (wrapper for ALGLIB).")]
   [Creatable(CreatableAttribute.Categories.DataAnalysisRegression, Priority = 150)]
-  [StorableClass]
+  [StorableType("ee942d3e-a5dc-4950-9195-facdbb098e08")]
   public sealed class NearestNeighbourRegression : FixedDataAnalysisAlgorithm<IRegressionProblem> {
     private const string KParameterName = "K";
Index: branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/NearestNeighbour/NearestNeighbourRegressionSolution.cs
===================================================================
--- branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/NearestNeighbour/NearestNeighbourRegressionSolution.cs	(revision 14926)
+++ branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/NearestNeighbour/NearestNeighbourRegressionSolution.cs	(revision 14927)
@@ -22,5 +22,5 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Persistence;
 using HeuristicLab.Problems.DataAnalysis;
 
@@ -30,5 +30,5 @@
   /// </summary>
   [Item("NearestNeighbourRegressionSolution", "Represents a nearest neighbour solution for a regression problem which can be visualized in the GUI.")]
-  [StorableClass]
+  [StorableType("9aeb3a22-3f09-4a43-8c2f-1e296ccd76c6")]
   public sealed class NearestNeighbourRegressionSolution : RegressionSolution, INearestNeighbourRegressionSolution {
 
Index: branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/NeuralNetwork/NeuralNetworkClassification.cs
===================================================================
--- branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/NeuralNetwork/NeuralNetworkClassification.cs	(revision 14926)
+++ branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/NeuralNetwork/NeuralNetworkClassification.cs	(revision 14927)
@@ -29,5 +29,5 @@
 using HeuristicLab.Optimization;
 using HeuristicLab.Parameters;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Persistence;
 using HeuristicLab.Problems.DataAnalysis;
 
@@ -38,5 +38,5 @@
   [Item("Neural Network Classification (NN)", "Neural network classification data analysis algorithm (wrapper for ALGLIB). Further documentation: http://www.alglib.net/dataanalysis/neuralnetworks.php")]
   [Creatable(CreatableAttribute.Categories.DataAnalysisClassification, Priority = 130)]
-  [StorableClass]
+  [StorableType("a94d15c5-f146-4a6f-92ba-4217b1df4daa")]
   public sealed class NeuralNetworkClassification : FixedDataAnalysisAlgorithm<IClassificationProblem> {
     private const string DecayParameterName = "Decay";
@@ -115,7 +115,7 @@
     public NeuralNetworkClassification()
       : base() {
-      var validHiddenLayerValues = new ItemSet<IntValue>(new IntValue[] { 
-        (IntValue)new IntValue(0).AsReadOnly(), 
-        (IntValue)new IntValue(1).AsReadOnly(), 
+      var validHiddenLayerValues = new ItemSet<IntValue>(new IntValue[] {
+        (IntValue)new IntValue(0).AsReadOnly(),
+        (IntValue)new IntValue(1).AsReadOnly(),
         (IntValue)new IntValue(2).AsReadOnly() });
       var selectedHiddenLayerValue = (from v in validHiddenLayerValues
Index: branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/NeuralNetwork/NeuralNetworkClassificationSolution.cs
===================================================================
--- branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/NeuralNetwork/NeuralNetworkClassificationSolution.cs	(revision 14926)
+++ branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/NeuralNetwork/NeuralNetworkClassificationSolution.cs	(revision 14927)
@@ -22,5 +22,5 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Persistence;
 using HeuristicLab.Problems.DataAnalysis;
 
@@ -30,5 +30,5 @@
   /// </summary>
   [Item("NeuralNetworkClassificationSolution", "Represents a neural network solution for a classification problem which can be visualized in the GUI.")]
-  [StorableClass]
+  [StorableType("d49a080c-82d0-4e94-b538-b5b137674e00")]
   public sealed class NeuralNetworkClassificationSolution : ClassificationSolution, INeuralNetworkClassificationSolution {
 
Index: branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/NeuralNetwork/NeuralNetworkEnsembleClassification.cs
===================================================================
--- branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/NeuralNetwork/NeuralNetworkEnsembleClassification.cs	(revision 14926)
+++ branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/NeuralNetwork/NeuralNetworkEnsembleClassification.cs	(revision 14927)
@@ -29,5 +29,5 @@
 using HeuristicLab.Optimization;
 using HeuristicLab.Parameters;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Persistence;
 using HeuristicLab.Problems.DataAnalysis;
 
@@ -38,5 +38,5 @@
   [Item("Neural Network Ensemble Classification (NN)", "Neural network ensemble classification data analysis algorithm (wrapper for ALGLIB). Further documentation: http://www.alglib.net/dataanalysis/mlpensembles.php")]
   [Creatable(CreatableAttribute.Categories.DataAnalysisClassification, Priority = 140)]
-  [StorableClass]
+  [StorableType("4c744749-c133-41fb-b098-f1ca2f7213e7")]
   public sealed class NeuralNetworkEnsembleClassification : FixedDataAnalysisAlgorithm<IClassificationProblem> {
     private const string EnsembleSizeParameterName = "EnsembleSize";
Index: branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/NeuralNetwork/NeuralNetworkEnsembleClassificationSolution.cs
===================================================================
--- branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/NeuralNetwork/NeuralNetworkEnsembleClassificationSolution.cs	(revision 14926)
+++ branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/NeuralNetwork/NeuralNetworkEnsembleClassificationSolution.cs	(revision 14927)
@@ -22,5 +22,5 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Persistence;
 using HeuristicLab.Problems.DataAnalysis;
 
@@ -30,5 +30,5 @@
   /// </summary>
   [Item("NeuralNetworkEnsembleClassificationSolution", "Represents a neural network ensemble solution for a classification problem which can be visualized in the GUI.")]
-  [StorableClass]
+  [StorableType("35d10454-d0a0-4257-b065-d92b278b7c2f")]
   public sealed class NeuralNetworkEnsembleClassificationSolution : ClassificationSolution, INeuralNetworkEnsembleClassificationSolution {
 
Index: branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/NeuralNetwork/NeuralNetworkEnsembleModel.cs
===================================================================
--- branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/NeuralNetwork/NeuralNetworkEnsembleModel.cs	(revision 14926)
+++ branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/NeuralNetwork/NeuralNetworkEnsembleModel.cs	(revision 14927)
@@ -25,5 +25,5 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Persistence;
 using HeuristicLab.Problems.DataAnalysis;
 
@@ -32,5 +32,5 @@
   /// Represents a neural network ensembel model for regression and classification
   /// </summary>
-  [StorableClass]
+  [StorableType("0d6dfe68-7903-4f2f-af46-e71ae2fbaf2d")]
   [Item("NeuralNetworkEnsembleModel", "Represents a neural network ensemble for regression and classification.")]
   public sealed class NeuralNetworkEnsembleModel : ClassificationModel, INeuralNetworkEnsembleModel {
Index: branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/NeuralNetwork/NeuralNetworkEnsembleRegression.cs
===================================================================
--- branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/NeuralNetwork/NeuralNetworkEnsembleRegression.cs	(revision 14926)
+++ branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/NeuralNetwork/NeuralNetworkEnsembleRegression.cs	(revision 14927)
@@ -29,5 +29,5 @@
 using HeuristicLab.Optimization;
 using HeuristicLab.Parameters;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Persistence;
 using HeuristicLab.Problems.DataAnalysis;
 
@@ -38,5 +38,5 @@
   [Item("Neural Network Ensemble Regression (NN)", "Neural network ensemble regression data analysis algorithm (wrapper for ALGLIB). Further documentation: http://www.alglib.net/dataanalysis/mlpensembles.php")]
   [Creatable(CreatableAttribute.Categories.DataAnalysisRegression, Priority = 140)]
-  [StorableClass]
+  [StorableType("2b8bff18-1fd5-443b-b370-f529ca9afecf")]
   public sealed class NeuralNetworkEnsembleRegression : FixedDataAnalysisAlgorithm<IRegressionProblem> {
     private const string EnsembleSizeParameterName = "EnsembleSize";
@@ -125,7 +125,7 @@
     public NeuralNetworkEnsembleRegression()
       : base() {
-      var validHiddenLayerValues = new ItemSet<IntValue>(new IntValue[] { 
-        (IntValue)new IntValue(0).AsReadOnly(), 
-        (IntValue)new IntValue(1).AsReadOnly(), 
+      var validHiddenLayerValues = new ItemSet<IntValue>(new IntValue[] {
+        (IntValue)new IntValue(0).AsReadOnly(),
+        (IntValue)new IntValue(1).AsReadOnly(),
         (IntValue)new IntValue(2).AsReadOnly() });
       var selectedHiddenLayerValue = (from v in validHiddenLayerValues
Index: branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/NeuralNetwork/NeuralNetworkEnsembleRegressionSolution.cs
===================================================================
--- branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/NeuralNetwork/NeuralNetworkEnsembleRegressionSolution.cs	(revision 14926)
+++ branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/NeuralNetwork/NeuralNetworkEnsembleRegressionSolution.cs	(revision 14927)
@@ -22,5 +22,5 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Persistence;
 using HeuristicLab.Problems.DataAnalysis;
 
@@ -30,5 +30,5 @@
   /// </summary>
   [Item("NeuralNetworkEnsembleRegressionSolution", "Represents a neural network ensemble solution for a regression problem which can be visualized in the GUI.")]
-  [StorableClass]
+  [StorableType("6006f404-fefe-4568-9297-9edfdd5a951b")]
   public sealed class NeuralNetworkEnsembleRegressionSolution : RegressionSolution, INeuralNetworkEnsembleRegressionSolution {
 
Index: branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/NeuralNetwork/NeuralNetworkModel.cs
===================================================================
--- branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/NeuralNetwork/NeuralNetworkModel.cs	(revision 14926)
+++ branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/NeuralNetwork/NeuralNetworkModel.cs	(revision 14927)
@@ -25,5 +25,5 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Persistence;
 using HeuristicLab.Problems.DataAnalysis;
 
@@ -32,5 +32,5 @@
   /// Represents a neural network model for regression and classification
   /// </summary>
-  [StorableClass]
+  [StorableType("6aed3009-9bad-4459-ac5c-6b4ad4e682d6")]
   [Item("NeuralNetworkModel", "Represents a neural network for regression and classification.")]
   public sealed class NeuralNetworkModel : ClassificationModel, INeuralNetworkModel {
@@ -112,5 +112,5 @@
 
     public override IEnumerable<double> GetEstimatedClassValues(IDataset dataset, IEnumerable<int> rows) {
-      double[,] inputData = dataset.ToArray( allowedInputVariables, rows);
+      double[,] inputData = dataset.ToArray(allowedInputVariables, rows);
 
       int n = inputData.GetLength(0);
Index: branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/NeuralNetwork/NeuralNetworkRegression.cs
===================================================================
--- branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/NeuralNetwork/NeuralNetworkRegression.cs	(revision 14926)
+++ branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/NeuralNetwork/NeuralNetworkRegression.cs	(revision 14927)
@@ -29,5 +29,5 @@
 using HeuristicLab.Optimization;
 using HeuristicLab.Parameters;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Persistence;
 using HeuristicLab.Problems.DataAnalysis;
 
@@ -38,5 +38,5 @@
   [Item("Neural Network Regression (NN)", "Neural network regression data analysis algorithm (wrapper for ALGLIB). Further documentation: http://www.alglib.net/dataanalysis/neuralnetworks.php")]
   [Creatable(CreatableAttribute.Categories.DataAnalysisRegression, Priority = 130)]
-  [StorableClass]
+  [StorableType("a7a3987c-f555-4c79-b22c-a2d50b42884f")]
   public sealed class NeuralNetworkRegression : FixedDataAnalysisAlgorithm<IRegressionProblem> {
     private const string DecayParameterName = "Decay";
@@ -115,7 +115,7 @@
     public NeuralNetworkRegression()
       : base() {
-      var validHiddenLayerValues = new ItemSet<IntValue>(new IntValue[] { 
-        (IntValue)new IntValue(0).AsReadOnly(), 
-        (IntValue)new IntValue(1).AsReadOnly(), 
+      var validHiddenLayerValues = new ItemSet<IntValue>(new IntValue[] {
+        (IntValue)new IntValue(0).AsReadOnly(),
+        (IntValue)new IntValue(1).AsReadOnly(),
         (IntValue)new IntValue(2).AsReadOnly() });
       var selectedHiddenLayerValue = (from v in validHiddenLayerValues
Index: branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/NeuralNetwork/NeuralNetworkRegressionSolution.cs
===================================================================
--- branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/NeuralNetwork/NeuralNetworkRegressionSolution.cs	(revision 14926)
+++ branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/NeuralNetwork/NeuralNetworkRegressionSolution.cs	(revision 14927)
@@ -22,5 +22,5 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Persistence;
 using HeuristicLab.Problems.DataAnalysis;
 
@@ -30,5 +30,5 @@
   /// </summary>
   [Item("NeuralNetworkRegressionSolution", "Represents a neural network solution for a regression problem which can be visualized in the GUI.")]
-  [StorableClass]
+  [StorableType("0c766f7e-ba57-4f9d-b4e3-6ed7dc4c57dc")]
   public sealed class NeuralNetworkRegressionSolution : RegressionSolution, INeuralNetworkRegressionSolution {
 
Index: branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/NonlinearRegression/NonlinearRegression.cs
===================================================================
--- branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/NonlinearRegression/NonlinearRegression.cs	(revision 14926)
+++ branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/NonlinearRegression/NonlinearRegression.cs	(revision 14927)
@@ -30,5 +30,5 @@
 using HeuristicLab.Optimization;
 using HeuristicLab.Parameters;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Persistence;
 using HeuristicLab.Problems.DataAnalysis;
 using HeuristicLab.Problems.DataAnalysis.Symbolic;
@@ -42,5 +42,5 @@
   [Item("Nonlinear Regression (NLR)", "Nonlinear regression (curve fitting) data analysis algorithm (wrapper for ALGLIB).")]
   [Creatable(CreatableAttribute.Categories.DataAnalysisRegression, Priority = 120)]
-  [StorableClass]
+  [StorableType("8cb4fd12-e936-4a3f-befa-95baa246c0fb")]
   public sealed class NonlinearRegression : FixedDataAnalysisAlgorithm<IRegressionProblem> {
     private const string RegressionSolutionResultName = "Regression solution";
Index: branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/RandomForest/RandomForestClassification.cs
===================================================================
--- branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/RandomForest/RandomForestClassification.cs	(revision 14926)
+++ branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/RandomForest/RandomForestClassification.cs	(revision 14927)
@@ -26,5 +26,5 @@
 using HeuristicLab.Optimization;
 using HeuristicLab.Parameters;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Persistence;
 using HeuristicLab.Problems.DataAnalysis;
 
@@ -35,5 +35,5 @@
   [Item("Random Forest Classification (RF)", "Random forest classification data analysis algorithm (wrapper for ALGLIB).")]
   [Creatable(CreatableAttribute.Categories.DataAnalysisClassification, Priority = 120)]
-  [StorableClass]
+  [StorableType("a8f44bf0-106c-492a-900a-ac5929527677")]
   public sealed class RandomForestClassification : FixedDataAnalysisAlgorithm<IClassificationProblem> {
     private const string RandomForestClassificationModelResultName = "Random forest classification solution";
Index: branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/RandomForest/RandomForestClassificationSolution.cs
===================================================================
--- branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/RandomForest/RandomForestClassificationSolution.cs	(revision 14926)
+++ branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/RandomForest/RandomForestClassificationSolution.cs	(revision 14927)
@@ -22,5 +22,5 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Persistence;
 using HeuristicLab.Problems.DataAnalysis;
 
@@ -30,5 +30,5 @@
   /// </summary>
   [Item("RandomForestClassificationSolution", "Represents a random forest solution for a classification problem which can be visualized in the GUI.")]
-  [StorableClass]
+  [StorableType("fe3da2ee-6219-4a66-8c5b-aa298634bc9f")]
   public sealed class RandomForestClassificationSolution : ClassificationSolution, IRandomForestClassificationSolution {
 
Index: branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/RandomForest/RandomForestModel.cs
===================================================================
--- branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/RandomForest/RandomForestModel.cs	(revision 14926)
+++ branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/RandomForest/RandomForestModel.cs	(revision 14927)
@@ -26,5 +26,5 @@
 using HeuristicLab.Core;
 using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Persistence;
 using HeuristicLab.Problems.DataAnalysis;
 using HeuristicLab.Problems.DataAnalysis.Symbolic;
@@ -34,5 +34,5 @@
   /// Represents a random forest model for regression and classification
   /// </summary>
-  [StorableClass]
+  [StorableType("6b729f71-aa91-42d1-80de-1f78fba6ed69")]
   [Item("RandomForestModel", "Represents a random forest for regression and classification.")]
   public sealed class RandomForestModel : ClassificationModel, IRandomForestModel {
Index: branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/RandomForest/RandomForestRegression.cs
===================================================================
--- branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/RandomForest/RandomForestRegression.cs	(revision 14926)
+++ branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/RandomForest/RandomForestRegression.cs	(revision 14927)
@@ -26,5 +26,5 @@
 using HeuristicLab.Optimization;
 using HeuristicLab.Parameters;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Persistence;
 using HeuristicLab.Problems.DataAnalysis;
 
@@ -35,5 +35,5 @@
   [Item("Random Forest Regression (RF)", "Random forest regression data analysis algorithm (wrapper for ALGLIB).")]
   [Creatable(CreatableAttribute.Categories.DataAnalysisRegression, Priority = 120)]
-  [StorableClass]
+  [StorableType("2dce3c52-3772-4eca-8543-e1bdb470ef80")]
   public sealed class RandomForestRegression : FixedDataAnalysisAlgorithm<IRegressionProblem> {
     private const string RandomForestRegressionModelResultName = "Random forest regression solution";
Index: branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/RandomForest/RandomForestRegressionSolution.cs
===================================================================
--- branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/RandomForest/RandomForestRegressionSolution.cs	(revision 14926)
+++ branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/RandomForest/RandomForestRegressionSolution.cs	(revision 14927)
@@ -23,5 +23,5 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Persistence;
 using HeuristicLab.Problems.DataAnalysis;
 using HeuristicLab.Problems.DataAnalysis.Symbolic.Regression;
@@ -32,5 +32,5 @@
   /// </summary>
   [Item("RandomForestRegressionSolution", "Represents a random forest solution for a regression problem which can be visualized in the GUI.")]
-  [StorableClass]
+  [StorableType("b191b7ec-5c36-454d-a980-e0977d926409")]
   public sealed class RandomForestRegressionSolution : ConfidenceRegressionSolution, IRandomForestRegressionSolution {
 
Index: branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/RandomForest/RandomForestUtil.cs
===================================================================
--- branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/RandomForest/RandomForestUtil.cs	(revision 14926)
+++ branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/RandomForest/RandomForestUtil.cs	(revision 14927)
@@ -31,5 +31,5 @@
 using HeuristicLab.Data;
 using HeuristicLab.Parameters;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Persistence;
 using HeuristicLab.Problems.DataAnalysis;
 using HeuristicLab.Random;
@@ -37,5 +37,5 @@
 namespace HeuristicLab.Algorithms.DataAnalysis {
   [Item("RFParameter", "A random forest parameter collection")]
-  [StorableClass]
+  [StorableType("e25f6027-e05c-4771-b408-db8aaeec8eca")]
   public class RFParameter : ParameterCollection {
     public RFParameter() {
Index: branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/SupportVectorMachine/SupportVectorClassification.cs
===================================================================
--- branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/SupportVectorMachine/SupportVectorClassification.cs	(revision 14926)
+++ branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/SupportVectorMachine/SupportVectorClassification.cs	(revision 14927)
@@ -29,5 +29,5 @@
 using HeuristicLab.Optimization;
 using HeuristicLab.Parameters;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Persistence;
 using HeuristicLab.Problems.DataAnalysis;
 using LibSVM;
@@ -39,5 +39,5 @@
   [Item("Support Vector Classification (SVM)", "Support vector machine classification data analysis algorithm (wrapper for libSVM).")]
   [Creatable(CreatableAttribute.Categories.DataAnalysisClassification, Priority = 110)]
-  [StorableClass]
+  [StorableType("0afc8417-1803-4fe2-9d1e-35e1980bd750")]
   public sealed class SupportVectorClassification : FixedDataAnalysisAlgorithm<IClassificationProblem> {
     private const string SvmTypeParameterName = "SvmType";
Index: branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/SupportVectorMachine/SupportVectorClassificationSolution.cs
===================================================================
--- branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/SupportVectorMachine/SupportVectorClassificationSolution.cs	(revision 14926)
+++ branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/SupportVectorMachine/SupportVectorClassificationSolution.cs	(revision 14927)
@@ -22,5 +22,5 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Persistence;
 using HeuristicLab.Problems.DataAnalysis;
 
@@ -30,5 +30,5 @@
   /// </summary>
   [Item("SupportVectorClassificationSolution", "Represents a support vector solution for a classification problem which can be visualized in the GUI.")]
-  [StorableClass]
+  [StorableType("8d0b623a-6d21-4566-b740-b7f72e7f9768")]
   public sealed class SupportVectorClassificationSolution : ClassificationSolution, ISupportVectorMachineSolution {
 
Index: branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/SupportVectorMachine/SupportVectorMachineModel.cs
===================================================================
--- branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/SupportVectorMachine/SupportVectorMachineModel.cs	(revision 14926)
+++ branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/SupportVectorMachine/SupportVectorMachineModel.cs	(revision 14927)
@@ -27,5 +27,5 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Persistence;
 using HeuristicLab.Problems.DataAnalysis;
 using LibSVM;
@@ -35,5 +35,5 @@
   /// Represents a support vector machine model.
   /// </summary>
-  [StorableClass]
+  [StorableType("89e1ee58-5387-4e56-9fca-a9437c0de1b0")]
   [Item("SupportVectorMachineModel", "Represents a support vector machine model.")]
   public sealed class SupportVectorMachineModel : ClassificationModel, ISupportVectorMachineModel {
Index: branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/SupportVectorMachine/SupportVectorRegression.cs
===================================================================
--- branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/SupportVectorMachine/SupportVectorRegression.cs	(revision 14926)
+++ branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/SupportVectorMachine/SupportVectorRegression.cs	(revision 14927)
@@ -29,5 +29,5 @@
 using HeuristicLab.Optimization;
 using HeuristicLab.Parameters;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Persistence;
 using HeuristicLab.Problems.DataAnalysis;
 using LibSVM;
@@ -39,5 +39,5 @@
   [Item("Support Vector Regression (SVM)", "Support vector machine regression data analysis algorithm (wrapper for libSVM).")]
   [Creatable(CreatableAttribute.Categories.DataAnalysisRegression, Priority = 110)]
-  [StorableClass]
+  [StorableType("2a83b4d0-6889-44c5-be59-6e7f49918203")]
   public sealed class SupportVectorRegression : FixedDataAnalysisAlgorithm<IRegressionProblem> {
     private const string SvmTypeParameterName = "SvmType";
Index: branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/SupportVectorMachine/SupportVectorRegressionSolution.cs
===================================================================
--- branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/SupportVectorMachine/SupportVectorRegressionSolution.cs	(revision 14926)
+++ branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/SupportVectorMachine/SupportVectorRegressionSolution.cs	(revision 14927)
@@ -22,5 +22,5 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Persistence;
 using HeuristicLab.Problems.DataAnalysis;
 
@@ -30,5 +30,5 @@
   /// </summary>
   [Item("SupportVectorRegressionSolution", "Represents a support vector solution for a regression problem which can be visualized in the GUI.")]
-  [StorableClass]
+  [StorableType("813a9851-fb65-47e8-9a43-286c9b7fe132")]
   public sealed class SupportVectorRegressionSolution : RegressionSolution, ISupportVectorMachineSolution {
 
Index: branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/TSNE/Distances/DistanceBase.cs
===================================================================
--- branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/TSNE/Distances/DistanceBase.cs	(revision 14926)
+++ branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/TSNE/Distances/DistanceBase.cs	(revision 14927)
@@ -24,8 +24,8 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Persistence;
 
 namespace HeuristicLab.Algorithms.DataAnalysis {
-  [StorableClass]
+  [StorableType("b9ad40ed-4e7b-42d7-8bce-c78f5d5ea79d")]
   public abstract class DistanceBase<T> : Item, IDistance<T> {
 
Index: branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/TSNE/Distances/EuclideanDistance.cs
===================================================================
--- branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/TSNE/Distances/EuclideanDistance.cs	(revision 14926)
+++ branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/TSNE/Distances/EuclideanDistance.cs	(revision 14927)
@@ -25,8 +25,8 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Persistence;
 
 namespace HeuristicLab.Algorithms.DataAnalysis {
-  [StorableClass]
+  [StorableType("d5bea120-8b55-4531-ab8c-084def4e5d76")]
   [Item("EuclideanDistance", "A norm function that uses Euclidean distance")]
   public class EuclideanDistance : DistanceBase<IEnumerable<double>> {
Index: branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/TSNE/Distances/IndexedItemDistance.cs
===================================================================
--- branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/TSNE/Distances/IndexedItemDistance.cs	(revision 14926)
+++ branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/TSNE/Distances/IndexedItemDistance.cs	(revision 14927)
@@ -23,8 +23,8 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Persistence;
 
 namespace HeuristicLab.Algorithms.DataAnalysis {
-  [StorableClass]
+  [StorableType("9dd3a8aa-87d7-4818-b992-3e191c0277e1")]
   [Item("IndexedItemDistance", "A distance wrapper for indexed items")]
   internal class IndexedItemDistance<T> : DistanceBase<IndexedItem<T>> {
Index: branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/TSNE/Distances/InnerProductDistance.cs
===================================================================
--- branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/TSNE/Distances/InnerProductDistance.cs	(revision 14926)
+++ branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/TSNE/Distances/InnerProductDistance.cs	(revision 14927)
@@ -25,5 +25,5 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Persistence;
 
 namespace HeuristicLab.Algorithms.DataAnalysis {
@@ -33,5 +33,5 @@
   /// It is designed for vectors with all positive coordinates.
   /// </summary>
-  [StorableClass]
+  [StorableType("8610393e-1a38-4ba3-8f5e-037ebb1de87f")]
   [Item("InnerProductDistance", "The angluar distance as defined as a normalized distance measure dependent on the angle between two vectors.\nIt is designed for vectors with all positive coordinates")]
   public class InnerProductDistance : DistanceBase<IEnumerable<double>> {
@@ -53,9 +53,9 @@
       var ys = point2.GetEnumerator();
       var sum = 0.0;
-      while(xs.MoveNext() & ys.MoveNext()) {
-        if(xs.Current < 0 || ys.Current < 0) throw new ArgumentException("Inner product distance is only defined for vectors with non-negative elements");
+      while (xs.MoveNext() & ys.MoveNext()) {
+        if (xs.Current < 0 || ys.Current < 0) throw new ArgumentException("Inner product distance is only defined for vectors with non-negative elements");
         sum += xs.Current * ys.Current;
       }
-      if(xs.MoveNext() || ys.MoveNext()) throw new ArgumentException("Enumerables contain a different number of elements");
+      if (xs.MoveNext() || ys.MoveNext()) throw new ArgumentException("Enumerables contain a different number of elements");
       return sum;
     }
Index: branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/TSNE/Distances/ManhattanDistance.cs
===================================================================
--- branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/TSNE/Distances/ManhattanDistance.cs	(revision 14926)
+++ branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/TSNE/Distances/ManhattanDistance.cs	(revision 14927)
@@ -25,8 +25,8 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Persistence;
 
 namespace HeuristicLab.Algorithms.DataAnalysis {
-  [StorableClass]
+  [StorableType("c0d60ade-e44f-459b-b004-d064a1f452c0")]
   [Item("ManhattanDistance", "A distance function that uses block distance")]
   public class ManhattanDistance : DistanceBase<IEnumerable<double>> {
Index: branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/TSNE/PriorityQueue.cs
===================================================================
--- branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/TSNE/PriorityQueue.cs	(revision 14926)
+++ branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/TSNE/PriorityQueue.cs	(revision 14927)
@@ -63,5 +63,5 @@
 
     public KeyValuePair<TK, TV> PeekMin() {
-      if(size == 0) {
+      if (size == 0) {
         throw new InvalidOperationException("Heap is empty");
       }
@@ -86,25 +86,25 @@
       size = sz - 1;
       finalLayerDist++;
-      if(finalLayerDist == finalLayerSize) {
+      if (finalLayerDist == finalLayerSize) {
         finalLayerSize >>= 2;
         finalLayerDist = 0;
       }
 
-      while(succ < sz) {
+      while (succ < sz) {
         var minKey = data[succ].Key;
         var delta = 0;
 
         var otherKey = data[succ + 1].Key;
-        if(otherKey.CompareTo(minKey) < 0) {
+        if (otherKey.CompareTo(minKey) < 0) {
           minKey = otherKey;
           delta = 1;
         }
         otherKey = data[succ + 2].Key;
-        if(otherKey.CompareTo(minKey) < 0) {
+        if (otherKey.CompareTo(minKey) < 0) {
           minKey = otherKey;
           delta = 2;
         }
         otherKey = data[succ + 3].Key;
-        if(otherKey.CompareTo(minKey) < 0) {
+        if (otherKey.CompareTo(minKey) < 0) {
           minKey = otherKey;
           delta = 3;
@@ -136,5 +136,5 @@
       pred = pred - layerDist; // finally preds index
 
-      while(data[pred].Key.CompareTo(bubble) > 0) {  // must terminate since inf at root
+      while (data[pred].Key.CompareTo(bubble) > 0) {  // must terminate since inf at root
         data[hole].Key = data[pred].Key;
         data[hole].Value = data[pred].Value;
@@ -158,6 +158,6 @@
       finalLayerDist--;
 
-      if(finalLayerDist == -1) { // layer full
-                                 // start next layer
+      if (finalLayerDist == -1) { // layer full
+                                  // start next layer
         finalLayerSize <<= 2;
         finalLayerDist = finalLayerSize - 1;
@@ -172,5 +172,5 @@
       pred = pred - layerDist; // finally preds index
       var predKey = data[pred].Key;
-      while(predKey.CompareTo(key) > 0) {
+      while (predKey.CompareTo(key) > 0) {
         data[hole].Key = predKey;
         data[hole].Value = data[pred].Value;
@@ -195,5 +195,5 @@
       var sup = Supremum;
       var cap = capacity;
-      for(var i = 1; i <= cap; i++) {
+      for (var i = 1; i <= cap; i++) {
         data[i].Key = sup;
       }
Index: branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/TSNE/TSNEAlgorithm.cs
===================================================================
--- branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/TSNE/TSNEAlgorithm.cs	(revision 14926)
+++ branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/TSNE/TSNEAlgorithm.cs	(revision 14927)
@@ -31,5 +31,5 @@
 using HeuristicLab.Optimization;
 using HeuristicLab.Parameters;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Persistence;
 using HeuristicLab.Problems.DataAnalysis;
 using HeuristicLab.Random;
@@ -43,5 +43,5 @@
                 "dimensional space to allow visual cluster identification.")]
   [Creatable(CreatableAttribute.Categories.DataAnalysis, Priority = 100)]
-  [StorableClass]
+  [StorableType("d2c00bc0-ece7-40f0-aac3-4ddfa0ec2697")]
   public sealed class TSNEAlgorithm : BasicAlgorithm {
     public override bool SupportsPause {
@@ -198,6 +198,6 @@
 
     private TSNEAlgorithm(TSNEAlgorithm original, Cloner cloner) : base(original, cloner) {
-      if(original.dataRowNames!=null)
-      this.dataRowNames = new Dictionary<string, List<int>>(original.dataRowNames);
+      if (original.dataRowNames != null)
+        this.dataRowNames = new Dictionary<string, List<int>>(original.dataRowNames);
       if (original.dataRows != null)
         this.dataRows = original.dataRows.ToDictionary(kvp => kvp.Key, kvp => cloner.Clone(kvp.Value));
Index: branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/TSNE/TSNEStatic.cs
===================================================================
--- branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/TSNE/TSNEStatic.cs	(revision 14926)
+++ branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/TSNE/TSNEStatic.cs	(revision 14927)
@@ -61,12 +61,12 @@
 using HeuristicLab.Core;
 using HeuristicLab.Optimization;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Persistence;
 using HeuristicLab.Random;
 
 namespace HeuristicLab.Algorithms.DataAnalysis {
-  [StorableClass]
+  [StorableType("04a40443-c8d6-4ed7-b7e3-acfff2128abc")]
   public class TSNEStatic<T> {
 
-    [StorableClass]
+    [StorableType("3a049a41-c91d-430d-96a6-9030b9693304")]
     public sealed class TSNEState : DeepCloneable {
       // initialized once
@@ -135,17 +135,17 @@
         this.eta = original.eta;
         this.newDimensions = original.newDimensions;
-        if(original.valP != null) {
+        if (original.valP != null) {
           this.valP = new double[original.valP.Length];
           Array.Copy(original.valP, this.valP, this.valP.Length);
         }
-        if(original.rowP != null) {
+        if (original.rowP != null) {
           this.rowP = new int[original.rowP.Length];
           Array.Copy(original.rowP, this.rowP, this.rowP.Length);
         }
-        if(original.colP != null) {
+        if (original.colP != null) {
           this.colP = new int[original.colP.Length];
           Array.Copy(original.colP, this.colP, this.colP.Length);
         }
-        if(original.p != null) {
+        if (original.p != null) {
           this.p = new double[original.p.GetLength(0), original.p.GetLength(1)];
           Array.Copy(original.p, this.p, this.p.Length);
@@ -184,5 +184,5 @@
         // initialize
         noDatapoints = data.Length;
-        if(noDatapoints - 1 < 3 * perplexity)
+        if (noDatapoints - 1 < 3 * perplexity)
           throw new ArgumentException("Perplexity too large for the number of data points!");
 
@@ -192,6 +192,6 @@
         uY = new double[noDatapoints, newDimensions];
         gains = new double[noDatapoints, newDimensions];
-        for(var i = 0; i < noDatapoints; i++)
-          for(var j = 0; j < newDimensions; j++)
+        for (var i = 0; i < noDatapoints; i++)
+          for (var j = 0; j < newDimensions; j++)
             gains[i, j] = 1.0;
 
@@ -206,11 +206,11 @@
 
         // Lie about the P-values (factor is 4 in the MATLAB implementation)
-        if(exact) for(var i = 0; i < noDatapoints; i++) for(var j = 0; j < noDatapoints; j++) p[i, j] *= 12.0;
-        else for(var i = 0; i < rowP[noDatapoints]; i++) valP[i] *= 12.0;
+        if (exact) for (var i = 0; i < noDatapoints; i++) for (var j = 0; j < noDatapoints; j++) p[i, j] *= 12.0;
+        else for (var i = 0; i < rowP[noDatapoints]; i++) valP[i] *= 12.0;
 
         // Initialize solution (randomly)
         var rand = new NormalDistributedRandom(random, 0, 1);
-        for(var i = 0; i < noDatapoints; i++)
-          for(var j = 0; j < newDimensions; j++)
+        for (var i = 0; i < noDatapoints; i++)
+          for (var j = 0; j < newDimensions; j++)
             newData[i, j] = rand.NextDouble() * .0001;
       }
@@ -233,6 +233,6 @@
         valP = sValP;
         var sumP = .0;
-        for(var i = 0; i < rowP[data.Length]; i++) sumP += valP[i];
-        for(var i = 0; i < rowP[data.Length]; i++) valP[i] /= sumP;
+        for (var i = 0; i < rowP[data.Length]; i++) sumP += valP[i];
+        for (var i = 0; i < rowP[data.Length]; i++) valP[i] /= sumP;
       }
 
@@ -242,6 +242,6 @@
         ComputeGaussianPerplexity(data, distance, p, perplexity);
         // Symmetrize input similarities
-        for(var n = 0; n < data.Length; n++) {
-          for(var m = n + 1; m < data.Length; m++) {
+        for (var n = 0; n < data.Length; n++) {
+          for (var m = n + 1; m < data.Length; m++) {
             p[n, m] += p[m, n];
             p[m, n] = p[n, m];
@@ -249,11 +249,11 @@
         }
         var sumP = .0;
-        for(var i = 0; i < data.Length; i++) for(var j = 0; j < data.Length; j++) sumP += p[i, j];
-        for(var i = 0; i < data.Length; i++) for(var j = 0; j < data.Length; j++) p[i, j] /= sumP;
+        for (var i = 0; i < data.Length; i++) for (var j = 0; j < data.Length; j++) sumP += p[i, j];
+        for (var i = 0; i < data.Length; i++) for (var j = 0; j < data.Length; j++) p[i, j] /= sumP;
         return p;
       }
 
       private static void ComputeGaussianPerplexity(IReadOnlyList<T> x, IDistance<T> distance, out int[] rowP, out int[] colP, out double[] valP, double perplexity, int k) {
-        if(perplexity > k) throw new ArgumentException("Perplexity should be lower than k!");
+        if (perplexity > k) throw new ArgumentException("Perplexity should be lower than k!");
 
         int n = x.Count;
@@ -264,8 +264,8 @@
         var curP = new double[n - 1];
         rowP[0] = 0;
-        for(var i = 0; i < n; i++) rowP[i + 1] = rowP[i] + k;
+        for (var i = 0; i < n; i++) rowP[i + 1] = rowP[i] + k;
 
         var objX = new List<IndexedItem<T>>();
-        for(var i = 0; i < n; i++) objX.Add(new IndexedItem<T>(i, x[i]));
+        for (var i = 0; i < n; i++) objX.Add(new IndexedItem<T>(i, x[i]));
 
         // Build ball tree on data set
@@ -273,5 +273,5 @@
 
         // Loop over all points to find nearest neighbors
-        for(var i = 0; i < n; i++) {
+        for (var i = 0; i < n; i++) {
           IList<IndexedItem<T>> indices;
           IList<double> distances;
@@ -285,28 +285,28 @@
           var minBeta = double.MinValue;
           var maxBeta = double.MaxValue;
-          const double tol = 1e-5;  
+          const double tol = 1e-5;
 
           // Iterate until we found a good perplexity
           var iter = 0; double sumP = 0;
-          while(!found && iter < 200) {  
+          while (!found && iter < 200) {
 
             // Compute Gaussian kernel row
-            for(var m = 0; m < k; m++) curP[m] = Math.Exp(-beta * distances[m + 1]); 
+            for (var m = 0; m < k; m++) curP[m] = Math.Exp(-beta * distances[m + 1]);
 
             // Compute entropy of current row
             sumP = double.Epsilon;
-            for(var m = 0; m < k; m++) sumP += curP[m];
+            for (var m = 0; m < k; m++) sumP += curP[m];
             var h = .0;
-            for(var m = 0; m < k; m++) h += beta * (distances[m + 1] * curP[m]); 
+            for (var m = 0; m < k; m++) h += beta * (distances[m + 1] * curP[m]);
             h = h / sumP + Math.Log(sumP);
 
             // Evaluate whether the entropy is within the tolerance level
             var hdiff = h - Math.Log(perplexity);
-            if(hdiff < tol && -hdiff < tol) {
+            if (hdiff < tol && -hdiff < tol) {
               found = true;
             } else {
-              if(hdiff > 0) {
+              if (hdiff > 0) {
                 minBeta = beta;
-                if(maxBeta.IsAlmost(double.MaxValue) || maxBeta.IsAlmost(double.MinValue))
+                if (maxBeta.IsAlmost(double.MaxValue) || maxBeta.IsAlmost(double.MinValue))
                   beta *= 2.0;
                 else
@@ -314,5 +314,5 @@
               } else {
                 maxBeta = beta;
-                if(minBeta.IsAlmost(double.MinValue) || minBeta.IsAlmost(double.MaxValue))
+                if (minBeta.IsAlmost(double.MinValue) || minBeta.IsAlmost(double.MaxValue))
                   beta /= 2.0;
                 else
@@ -326,6 +326,6 @@
 
           // Row-normalize current row of P and store in matrix
-          for(var m = 0; m < k; m++) curP[m] /= sumP;
-          for(var m = 0; m < k; m++) {
+          for (var m = 0; m < k; m++) curP[m] /= sumP;
+          for (var m = 0; m < k; m++) {
             colP[rowP[i] + m] = indices[m + 1].Index;
             valP[rowP[i] + m] = curP[m];
@@ -339,5 +339,5 @@
         int n = x.Length;
         // Compute the Gaussian kernel row by row
-        for(var i = 0; i < n; i++) {
+        for (var i = 0; i < n; i++) {
           // Initialize some variables
           var found = false;
@@ -350,25 +350,25 @@
           // Iterate until we found a good perplexity
           var iter = 0;
-          while(!found && iter < 200) {      // 200 iterations as in tSNE implementation by van der Maarten
+          while (!found && iter < 200) {      // 200 iterations as in tSNE implementation by van der Maarten
 
             // Compute Gaussian kernel row
-            for(var m = 0; m < n; m++) p[i, m] = Math.Exp(-beta * dd[i][m]);
+            for (var m = 0; m < n; m++) p[i, m] = Math.Exp(-beta * dd[i][m]);
             p[i, i] = double.Epsilon;
 
             // Compute entropy of current row
             sumP = double.Epsilon;
-            for(var m = 0; m < n; m++) sumP += p[i, m];
+            for (var m = 0; m < n; m++) sumP += p[i, m];
             var h = 0.0;
-            for(var m = 0; m < n; m++) h += beta * (dd[i][m] * p[i, m]);
+            for (var m = 0; m < n; m++) h += beta * (dd[i][m] * p[i, m]);
             h = h / sumP + Math.Log(sumP);
 
             // Evaluate whether the entropy is within the tolerance level
             var hdiff = h - Math.Log(perplexity);
-            if(hdiff < tol && -hdiff < tol) {
+            if (hdiff < tol && -hdiff < tol) {
               found = true;
             } else {
-              if(hdiff > 0) {
+              if (hdiff > 0) {
                 minBeta = beta;
-                if(maxBeta.IsAlmost(double.MaxValue) || maxBeta.IsAlmost(double.MinValue))
+                if (maxBeta.IsAlmost(double.MaxValue) || maxBeta.IsAlmost(double.MinValue))
                   beta *= 2.0;
                 else
@@ -376,5 +376,5 @@
               } else {
                 maxBeta = beta;
-                if(minBeta.IsAlmost(double.MinValue) || minBeta.IsAlmost(double.MaxValue))
+                if (minBeta.IsAlmost(double.MinValue) || minBeta.IsAlmost(double.MaxValue))
                   beta /= 2.0;
                 else
@@ -388,5 +388,5 @@
 
           // Row normalize P
-          for(var m = 0; m < n; m++) p[i, m] /= sumP;
+          for (var m = 0; m < n; m++) p[i, m] /= sumP;
         }
       }
@@ -394,12 +394,12 @@
       private static double[][] ComputeDistances(T[] x, IDistance<T> distance) {
         var res = new double[x.Length][];
-        for(int r = 0; r < x.Length; r++) {
+        for (int r = 0; r < x.Length; r++) {
           var rowV = new double[x.Length];
           // all distances must be symmetric 
-          for(int c = 0; c < r; c++) {
+          for (int c = 0; c < r; c++) {
             rowV[c] = res[c][r];
           }
           rowV[r] = 0.0; // distance to self is zero for all distances
-          for(int c = r + 1; c < x.Length; c++) {
+          for (int c = r + 1; c < x.Length; c++) {
             rowV[c] = distance.Get(x[r], x[c]);
           }
@@ -418,7 +418,7 @@
         // Compute Q-matrix and normalization sum
         var sumQ = double.Epsilon;
-        for(var n1 = 0; n1 < n; n1++) {
-          for(var m = 0; m < n; m++) {
-            if(n1 != m) {
+        for (var n1 = 0; n1 < n; n1++) {
+          for (var m = 0; m < n; m++) {
+            if (n1 != m) {
               q[n1, m] = 1 / (1 + dd[n1, m]);
               sumQ += q[n1, m];
@@ -426,10 +426,10 @@
           }
         }
-        for(var i = 0; i < n; i++) for(var j = 0; j < n; j++) q[i, j] /= sumQ;
+        for (var i = 0; i < n; i++) for (var j = 0; j < n; j++) q[i, j] /= sumQ;
 
         // Sum t-SNE error
         var c = .0;
-        for(var i = 0; i < n; i++)
-          for(var j = 0; j < n; j++) {
+        for (var i = 0; i < n; i++)
+          for (var j = 0; j < n; j++) {
             c += p[i, j] * Math.Log((p[i, j] + float.Epsilon) / (q[i, j] + float.Epsilon));
           }
@@ -445,14 +445,14 @@
         var buff = new double[d];
         double sumQ = 0.0;
-        for(var i = 0; i < n; i++) tree.ComputeNonEdgeForces(i, theta, buff, ref sumQ);
+        for (var i = 0; i < n; i++) tree.ComputeNonEdgeForces(i, theta, buff, ref sumQ);
 
         // Loop over all edges to compute t-SNE error
         var c = .0;
-        for(var k = 0; k < n; k++) {
-          for(var i = rowP[k]; i < rowP[k + 1]; i++) {
+        for (var k = 0; k < n; k++) {
+          for (var i = rowP[k]; i < rowP[k + 1]; i++) {
             var q = .0;
-            for(var j = 0; j < d; j++) buff[j] = y[k, j];
-            for(var j = 0; j < d; j++) buff[j] -= y[colP[i], j];
-            for(var j = 0; j < d; j++) q += buff[j] * buff[j];
+            for (var j = 0; j < d; j++) buff[j] = y[k, j];
+            for (var j = 0; j < d; j++) buff[j] -= y[colP[i], j];
+            for (var j = 0; j < d; j++) q += buff[j] * buff[j];
             q = (1.0 / (1.0 + q)) / sumQ;
             c += valP[i] * Math.Log((valP[i] + float.Epsilon) / (q + float.Epsilon));
@@ -466,13 +466,13 @@
         var n = rowP.Count - 1;
         var rowCounts = new int[n];
-        for(var j = 0; j < n; j++) {
-          for(var i = rowP[j]; i < rowP[j + 1]; i++) {
+        for (var j = 0; j < n; j++) {
+          for (var i = rowP[j]; i < rowP[j + 1]; i++) {
 
             // Check whether element (col_P[i], n) is present
             var present = false;
-            for(var m = rowP[colP[i]]; m < rowP[colP[i] + 1]; m++) {
-              if(colP[m] == j) present = true;
+            for (var m = rowP[colP[i]]; m < rowP[colP[i] + 1]; m++) {
+              if (colP[m] == j) present = true;
             }
-            if(present) rowCounts[j]++;
+            if (present) rowCounts[j]++;
             else {
               rowCounts[j]++;
@@ -482,5 +482,5 @@
         }
         var noElem = 0;
-        for(var i = 0; i < n; i++) noElem += rowCounts[i];
+        for (var i = 0; i < n; i++) noElem += rowCounts[i];
 
         // Allocate memory for symmetrized matrix
@@ -491,17 +491,17 @@
         // Construct new row indices for symmetric matrix
         symRowP[0] = 0;
-        for(var i = 0; i < n; i++) symRowP[i + 1] = symRowP[i] + rowCounts[i];
+        for (var i = 0; i < n; i++) symRowP[i + 1] = symRowP[i] + rowCounts[i];
 
         // Fill the result matrix
         var offset = new int[n];
-        for(var j = 0; j < n; j++) {
-          for(var i = rowP[j]; i < rowP[j + 1]; i++) {                                  // considering element(n, colP[i])
+        for (var j = 0; j < n; j++) {
+          for (var i = rowP[j]; i < rowP[j + 1]; i++) {                                  // considering element(n, colP[i])
 
             // Check whether element (col_P[i], n) is present
             var present = false;
-            for(var m = rowP[colP[i]]; m < rowP[colP[i] + 1]; m++) {
-              if(colP[m] != j) continue;
+            for (var m = rowP[colP[i]]; m < rowP[colP[i] + 1]; m++) {
+              if (colP[m] != j) continue;
               present = true;
-              if(j > colP[i]) continue; // make sure we do not add elements twice
+              if (j > colP[i]) continue; // make sure we do not add elements twice
               symColP[symRowP[j] + offset[j]] = colP[i];
               symColP[symRowP[colP[i]] + offset[colP[i]]] = j;
@@ -511,5 +511,5 @@
 
             // If (colP[i], n) is not present, there is no addition involved
-            if(!present) {
+            if (!present) {
               symColP[symRowP[j] + offset[j]] = colP[i];
               symColP[symRowP[colP[i]] + offset[colP[i]]] = j;
@@ -519,11 +519,11 @@
 
             // Update offsets
-            if(present && (j > colP[i])) continue;
+            if (present && (j > colP[i])) continue;
             offset[j]++;
-            if(colP[i] != j) offset[colP[i]]++;
-          }
-        }
-
-        for(var i = 0; i < noElem; i++) symValP[i] /= 2.0;
+            if (colP[i] != j) offset[colP[i]]++;
+          }
+        }
+
+        for (var i = 0; i < noElem; i++) symValP[i] /= 2.0;
       }
     }
@@ -554,5 +554,5 @@
         theta, stopLyingIter, momSwitchIter, momentum, finalMomentum, eta);
 
-      for(int i = 0; i < iterations - 1; i++) {
+      for (int i = 0; i < iterations - 1; i++) {
         Iterate(state);
       }
@@ -570,5 +570,5 @@
 
     public static double[,] Iterate(TSNEState state) {
-      if(state.exact)
+      if (state.exact)
         ComputeExactGradient(state.p, state.newData, state.noDatapoints, state.newDimensions, state.dY);
       else
@@ -576,11 +576,11 @@
 
       // Update gains
-      for(var i = 0; i < state.noDatapoints; i++) {
-        for(var j = 0; j < state.newDimensions; j++) {
+      for (var i = 0; i < state.noDatapoints; i++) {
+        for (var j = 0; j < state.newDimensions; j++) {
           state.gains[i, j] = Math.Sign(state.dY[i, j]) != Math.Sign(state.uY[i, j])
             ? state.gains[i, j] + .2  // +0.2 nd *0.8 are used in two separate implementations of tSNE -> seems to be correct
             : state.gains[i, j] * .8;
 
-          if(state.gains[i, j] < .01) state.gains[i, j] = .01;
+          if (state.gains[i, j] < .01) state.gains[i, j] = .01;
         }
       }
@@ -588,10 +588,10 @@
 
       // Perform gradient update (with momentum and gains)
-      for(var i = 0; i < state.noDatapoints; i++)
-        for(var j = 0; j < state.newDimensions; j++)
+      for (var i = 0; i < state.noDatapoints; i++)
+        for (var j = 0; j < state.newDimensions; j++)
           state.uY[i, j] = state.currentMomentum * state.uY[i, j] - state.eta * state.gains[i, j] * state.dY[i, j];
 
-      for(var i = 0; i < state.noDatapoints; i++)
-        for(var j = 0; j < state.newDimensions; j++)
+      for (var i = 0; i < state.noDatapoints; i++)
+        for (var j = 0; j < state.newDimensions; j++)
           state.newData[i, j] = state.newData[i, j] + state.uY[i, j];
 
@@ -600,15 +600,15 @@
 
       // Stop lying about the P-values after a while, and switch momentum
-      if(state.iter == state.stopLyingIter) {
-        if(state.exact)
-          for(var i = 0; i < state.noDatapoints; i++)
-            for(var j = 0; j < state.noDatapoints; j++)
+      if (state.iter == state.stopLyingIter) {
+        if (state.exact)
+          for (var i = 0; i < state.noDatapoints; i++)
+            for (var j = 0; j < state.noDatapoints; j++)
               state.p[i, j] /= 12.0;
         else
-          for(var i = 0; i < state.rowP[state.noDatapoints]; i++)
+          for (var i = 0; i < state.rowP[state.noDatapoints]; i++)
             state.valP[i] /= 12.0;
       }
 
-      if(state.iter == state.momSwitchIter)
+      if (state.iter == state.momSwitchIter)
         state.currentMomentum = state.finalMomentum;
 
@@ -626,13 +626,13 @@
       tree.ComputeEdgeForces(rowP, colP, valP, n, posF);
       var row = new double[d];
-      for(var n1 = 0; n1 < n; n1++) {
-        Array.Clear(row,0,row.Length);
+      for (var n1 = 0; n1 < n; n1++) {
+        Array.Clear(row, 0, row.Length);
         tree.ComputeNonEdgeForces(n1, theta, row, ref sumQ);
-        Buffer.BlockCopy(row, 0, negF, (sizeof(double) * n1 * d), d*sizeof(double));
+        Buffer.BlockCopy(row, 0, negF, (sizeof(double) * n1 * d), d * sizeof(double));
       }
 
       // Compute final t-SNE gradient
       for (var i = 0; i < n; i++)
-        for(var j = 0; j < d; j++) {
+        for (var j = 0; j < d; j++) {
           dC[i, j] = posF[i, j] - negF[i, j] / sumQ;
         }
@@ -642,5 +642,5 @@
 
       // Make sure the current gradient contains zeros
-      for(var i = 0; i < n; i++) for(var j = 0; j < d; j++) dC[i, j] = 0.0;
+      for (var i = 0; i < n; i++) for (var j = 0; j < d; j++) dC[i, j] = 0.0;
 
       // Compute the squared Euclidean distance matrix
@@ -651,7 +651,7 @@
       var q = new double[n, n];
       var sumQ = .0;
-      for(var n1 = 0; n1 < n; n1++) {
-        for(var m = 0; m < n; m++) {
-          if(n1 == m) continue;
+      for (var n1 = 0; n1 < n; n1++) {
+        for (var m = 0; m < n; m++) {
+          if (n1 == m) continue;
           q[n1, m] = 1 / (1 + dd[n1, m]);
           sumQ += q[n1, m];
@@ -660,9 +660,9 @@
 
       // Perform the computation of the gradient
-      for(var n1 = 0; n1 < n; n1++) {
-        for(var m = 0; m < n; m++) {
-          if(n1 == m) continue;
+      for (var n1 = 0; n1 < n; n1++) {
+        for (var m = 0; m < n; m++) {
+          if (n1 == m) continue;
           var mult = (p[n1, m] - q[n1, m] / sumQ) * q[n1, m];
-          for(var d1 = 0; d1 < d; d1++) {
+          for (var d1 = 0; d1 < d; d1++) {
             dC[n1, d1] += (y[n1, d1] - y[m, d1]) * mult;
           }
@@ -673,19 +673,19 @@
     private static void ComputeSquaredEuclideanDistance(double[,] x, int n, int d, double[,] dd) {
       var dataSums = new double[n];
-      for(var i = 0; i < n; i++) {
-        for(var j = 0; j < d; j++) {
+      for (var i = 0; i < n; i++) {
+        for (var j = 0; j < d; j++) {
           dataSums[i] += x[i, j] * x[i, j];
         }
       }
-      for(var i = 0; i < n; i++) {
-        for(var m = 0; m < n; m++) {
+      for (var i = 0; i < n; i++) {
+        for (var m = 0; m < n; m++) {
           dd[i, m] = dataSums[i] + dataSums[m];
         }
       }
-      for(var i = 0; i < n; i++) {
+      for (var i = 0; i < n; i++) {
         dd[i, i] = 0.0;
-        for(var m = i + 1; m < n; m++) {
+        for (var m = i + 1; m < n; m++) {
           dd[i, m] = 0.0;
-          for(var j = 0; j < d; j++) {
+          for (var j = 0; j < d; j++) {
             dd[i, m] += (x[i, j] - x[m, j]) * (x[i, j] - x[m, j]);
           }
@@ -700,15 +700,15 @@
       var d = x.GetLength(1);
       var mean = new double[d];
-      for(var i = 0; i < n; i++) {
-        for(var j = 0; j < d; j++) {
+      for (var i = 0; i < n; i++) {
+        for (var j = 0; j < d; j++) {
           mean[j] += x[i, j];
         }
       }
-      for(var i = 0; i < d; i++) {
+      for (var i = 0; i < d; i++) {
         mean[i] /= n;
       }
       // Subtract data mean
-      for(var i = 0; i < n; i++) {
-        for(var j = 0; j < d; j++) {
+      for (var i = 0; i < n; i++) {
+        for (var j = 0; j < d; j++) {
           x[i, j] -= mean[j];
         }
Index: branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/TSNE/VantagePointTree.cs
===================================================================
--- branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/TSNE/VantagePointTree.cs	(revision 14926)
+++ branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/TSNE/VantagePointTree.cs	(revision 14927)
@@ -93,5 +93,5 @@
         heap.RemoveMin();
       }
-      res.Reverse();  
+      res.Reverse();
       dist.Reverse();
       results = res;
@@ -104,5 +104,5 @@
       if (dist < tau) {
         if (heap.Size == k) heap.RemoveMin();   // remove furthest node from result list (if we already have k results) 
-        heap.Insert(-dist, new IndexedItem<double>(node.index, dist));      
+        heap.Insert(-dist, new IndexedItem<double>(node.index, dist));
         if (heap.Size == k) tau = heap.PeekMinValue().Value;
       }
Index: branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/TimeSeries/AutoregressiveModeling.cs
===================================================================
--- branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/TimeSeries/AutoregressiveModeling.cs	(revision 14926)
+++ branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/TimeSeries/AutoregressiveModeling.cs	(revision 14927)
@@ -29,5 +29,5 @@
 using HeuristicLab.Optimization;
 using HeuristicLab.Parameters;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Persistence;
 using HeuristicLab.Problems.DataAnalysis;
 using HeuristicLab.Problems.DataAnalysis.Symbolic;
@@ -37,5 +37,5 @@
   [Item("Autoregressive Modeling (AR)", "Timeseries modeling algorithm that creates AR-N models.")]
   [Creatable(CreatableAttribute.Categories.DataAnalysis, Priority = 130)]
-  [StorableClass]
+  [StorableType("ceaaeee5-9be2-40f4-a924-2d83ec8bf9d0")]
   public class AutoregressiveModeling : FixedDataAnalysisAlgorithm<ITimeSeriesPrognosisProblem> {
     private const string TimeOffesetParameterName = "Maximum Time Offset";
Index: branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/kMeans/KMeansClustering.cs
===================================================================
--- branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/kMeans/KMeansClustering.cs	(revision 14926)
+++ branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/kMeans/KMeansClustering.cs	(revision 14927)
@@ -29,5 +29,5 @@
 using HeuristicLab.Optimization;
 using HeuristicLab.Parameters;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Persistence;
 using HeuristicLab.Problems.DataAnalysis;
 
@@ -38,5 +38,5 @@
   [Item("k-Means", "The k-Means clustering algorithm (wrapper for ALGLIB).")]
   [Creatable(CreatableAttribute.Categories.DataAnalysis, Priority = 10)]
-  [StorableClass]
+  [StorableType("b85d0012-07d4-4601-87a4-2a6d19648b22")]
   public sealed class KMeansClustering : FixedDataAnalysisAlgorithm<IClusteringProblem> {
     private const string KParameterName = "k";
Index: branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/kMeans/KMeansClusteringModel.cs
===================================================================
--- branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/kMeans/KMeansClusteringModel.cs	(revision 14926)
+++ branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/kMeans/KMeansClusteringModel.cs	(revision 14927)
@@ -25,5 +25,5 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Persistence;
 using HeuristicLab.Problems.DataAnalysis;
 
@@ -32,5 +32,5 @@
   /// Represents a k-Means clustering model.
   /// </summary>
-  [StorableClass]
+  [StorableType("c5179f26-13f5-4427-80c6-7d3ed6fcdeec")]
   [Item("KMeansClusteringModel", "Represents a k-Means clustering model.")]
   public sealed class KMeansClusteringModel : NamedItem, IClusteringModel {
Index: branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/kMeans/KMeansClusteringSolution.cs
===================================================================
--- branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/kMeans/KMeansClusteringSolution.cs	(revision 14926)
+++ branches/PersistenceReintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/kMeans/KMeansClusteringSolution.cs	(revision 14927)
@@ -26,5 +26,5 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Persistence;
 using HeuristicLab.Problems.DataAnalysis;
 using HeuristicLab.Optimization;
@@ -36,5 +36,5 @@
   /// </summary>
   [Item("k-Means clustering solution", "Represents a k-Means solution for a clustering problem which can be visualized in the GUI.")]
-  [StorableClass]
+  [StorableType("43ef58af-7372-45d0-a8ef-a54746d33225")]
   public sealed class KMeansClusteringSolution : ClusteringSolution {
     private const string TrainingIntraClusterSumOfSquaresResultName = "Intra-cluster sum of squares (training)";
