Index: /branches/CMAES/HeuristicLab.Algorithms.CMAEvolutionStrategy/3.3/CMAAnalyzer.cs
===================================================================
--- /branches/CMAES/HeuristicLab.Algorithms.CMAEvolutionStrategy/3.3/CMAAnalyzer.cs	(revision 9296)
+++ /branches/CMAES/HeuristicLab.Algorithms.CMAEvolutionStrategy/3.3/CMAAnalyzer.cs	(revision 9297)
@@ -81,5 +81,5 @@
         results.Add(new Result("AxisRatio", axisRatio));
       }
-      axisRatio.Rows["AxisRatio"].Values.Add(sp.AxisRatio.Value);
+      axisRatio.Rows["AxisRatio"].Values.Add(sp.AxisRatio);
 
       DataTable sigma;
@@ -92,5 +92,5 @@
         results.Add(new Result("Sigma", sigma));
       }
-      sigma.Rows["Sigma"].Values.Add(sp.Sigma.Value);
+      sigma.Rows["Sigma"].Values.Add(sp.Sigma);
 
       DataTable scaling;
@@ -100,9 +100,9 @@
         scaling = new DataTable("Scaling");
         scaling.VisualProperties.YAxisLogScale = true;
-        for (int i = 0; i < sp.C.Rows; i++)
+        for (int i = 0; i < sp.C.GetLength(0); i++)
           scaling.Rows.Add(new DataRow("Axis" + i.ToString()));
         results.Add(new Result("Scaling", scaling));
       }
-      for (int i = 0; i < sp.C.Rows; i++)
+      for (int i = 0; i < sp.C.GetLength(0); i++)
         scaling.Rows["Axis" + i.ToString()].Values.Add(sp.D[i]);
 
Index: /branches/CMAES/HeuristicLab.Algorithms.CMAEvolutionStrategy/3.3/CMAOperators/CMAEqualweightedRecombinator.cs
===================================================================
--- /branches/CMAES/HeuristicLab.Algorithms.CMAEvolutionStrategy/3.3/CMAOperators/CMAEqualweightedRecombinator.cs	(revision 9296)
+++ /branches/CMAES/HeuristicLab.Algorithms.CMAEvolutionStrategy/3.3/CMAOperators/CMAEqualweightedRecombinator.cs	(revision 9297)
@@ -22,5 +22,4 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
-using HeuristicLab.Data;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
@@ -39,6 +38,6 @@
     }
 
-    protected override DoubleArray GetWeights(int mu) {
-      var weights = new DoubleArray(mu);
+    protected override double[] GetWeights(int mu) {
+      var weights = new double[mu];
       for (int i = 0; i < mu; i++)
         weights[i] = 1.0 / mu;
Index: /branches/CMAES/HeuristicLab.Algorithms.CMAEvolutionStrategy/3.3/CMAOperators/CMAInitializer.cs
===================================================================
--- /branches/CMAES/HeuristicLab.Algorithms.CMAEvolutionStrategy/3.3/CMAOperators/CMAInitializer.cs	(revision 9296)
+++ /branches/CMAES/HeuristicLab.Algorithms.CMAEvolutionStrategy/3.3/CMAOperators/CMAInitializer.cs	(revision 9297)
@@ -104,5 +104,5 @@
 
       var sp = new CMAParameters();
-      sp.Mu = mu == null ? new IntValue((int)Math.Floor(lambda / 2.0)) : new IntValue(mu.Value);
+      sp.Mu = mu == null ? (int)Math.Floor(lambda / 2.0) : mu.Value;
       sp.QualityHistorySize = 10 + 30 * N / lambda;
       sp.QualityHistory = new Queue<double>(sp.QualityHistorySize + 1);
@@ -169,15 +169,20 @@
 
       double maxD = D.Max(), minD = D.Min();
-      if (minD == 0) sp.AxisRatio = new DoubleValue(double.PositiveInfinity);
-      else sp.AxisRatio = new DoubleValue(maxD / minD);
-      sp.PC = new DoubleArray(pc);
-      sp.PS = new DoubleArray(ps);
-      sp.B = new DoubleMatrix(B);
-      sp.D = new DoubleArray(D);
-      sp.C = new DoubleMatrix(C);
-      sp.BDz = new DoubleArray(BDz);
-      sp.Sigma = new DoubleValue(sigma);
-      if (sigmaBounds != null) sp.SigmaBounds = (DoubleMatrix)sigmaBounds.Clone();
-      sp.InitialIterations = new IntValue(initialIterations.Value);
+      if (minD == 0) sp.AxisRatio = double.PositiveInfinity;
+      else sp.AxisRatio = maxD / minD;
+      sp.PC = pc;
+      sp.PS = ps;
+      sp.B = B;
+      sp.D = D;
+      sp.C = C;
+      sp.BDz = BDz;
+      sp.Sigma = sigma;
+      if (sigmaBounds != null) {
+        sp.SigmaBounds = new double[sigmaBounds.Rows, sigmaBounds.Columns];
+        for (int i = 0; i < sigmaBounds.Rows; i++)
+          for (int j = 0; j < sigmaBounds.Columns; j++)
+            sp.SigmaBounds[i, j] = sigmaBounds[i, j];
+      }
+      sp.InitialIterations = initialIterations.Value;
 
       StrategyParametersParameter.ActualValue = sp;
Index: /branches/CMAES/HeuristicLab.Algorithms.CMAEvolutionStrategy/3.3/CMAOperators/CMALinearweightedRecombinator.cs
===================================================================
--- /branches/CMAES/HeuristicLab.Algorithms.CMAEvolutionStrategy/3.3/CMAOperators/CMALinearweightedRecombinator.cs	(revision 9296)
+++ /branches/CMAES/HeuristicLab.Algorithms.CMAEvolutionStrategy/3.3/CMAOperators/CMALinearweightedRecombinator.cs	(revision 9297)
@@ -22,5 +22,4 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
-using HeuristicLab.Data;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
@@ -39,6 +38,6 @@
     }
 
-    protected override DoubleArray GetWeights(int mu) {
-      var weights = new DoubleArray(mu);
+    protected override double[] GetWeights(int mu) {
+      var weights = new double[mu];
       var sum = (mu + 1) * mu / 2.0; // sum of arithmetic progression mu..1
       for (int i = 0; i < mu; i++)
Index: /branches/CMAES/HeuristicLab.Algorithms.CMAEvolutionStrategy/3.3/CMAOperators/CMALogweightedRecombinator.cs
===================================================================
--- /branches/CMAES/HeuristicLab.Algorithms.CMAEvolutionStrategy/3.3/CMAOperators/CMALogweightedRecombinator.cs	(revision 9296)
+++ /branches/CMAES/HeuristicLab.Algorithms.CMAEvolutionStrategy/3.3/CMAOperators/CMALogweightedRecombinator.cs	(revision 9297)
@@ -22,5 +22,4 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
-using HeuristicLab.Data;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 using System;
@@ -41,6 +40,6 @@
     }
 
-    protected override DoubleArray GetWeights(int mu) {
-      var weights = new DoubleArray(mu);
+    protected override double[] GetWeights(int mu) {
+      var weights = new double[mu];
       for (int i = 0; i < mu; i++) weights[i] = Math.Log((mu + 1.0) / (i + 1.0));
       var sum = weights.Sum();
Index: /branches/CMAES/HeuristicLab.Algorithms.CMAEvolutionStrategy/3.3/CMAOperators/CMAMutator.cs
===================================================================
--- /branches/CMAES/HeuristicLab.Algorithms.CMAEvolutionStrategy/3.3/CMAOperators/CMAMutator.cs	(revision 9296)
+++ /branches/CMAES/HeuristicLab.Algorithms.CMAEvolutionStrategy/3.3/CMAOperators/CMAMutator.cs	(revision 9297)
@@ -106,5 +106,5 @@
       var sp = StrategyParametersParameter.ActualValue;
       var iterations = IterationsParameter.ActualValue.Value;
-      var initialIterations = sp.InitialIterations.Value;
+      var initialIterations = sp.InitialIterations;
       var bounds = BoundsParameter.ActualValue;
 
@@ -115,6 +115,4 @@
       }
       var nd = new NormalDistributedRandom(random, 0, 1);
-      //alglib.hqrndstate state;
-      //alglib.hqrndseed(random.Next(), random.Next(), out state);
 
       for (int i = 0; i < lambda; i++) {
@@ -124,5 +122,5 @@
           for (int k = 0; k < arx[i].Length; k++) {
             do {
-              arx[i][k] = xmean[k] + sp.Sigma.Value * sp.D[k] * nd.NextDouble(); //alglib.hqrndnormal(state);
+              arx[i][k] = xmean[k] + sp.Sigma * sp.D[k] * nd.NextDouble();
               inRange = bounds[k % bounds.Rows, 0] <= arx[i][k] && arx[i][k] <= bounds[k % bounds.Rows, 1];
               if (!inRange) tries++;
@@ -140,5 +138,5 @@
             var artmp = new double[arx[0].Length];
             for (int k = 0; k < arx[0].Length; ++k) {
-              artmp[k] = sp.D[k] * nd.NextDouble(); //alglib.hqrndnormal(state);
+              artmp[k] = sp.D[k] * nd.NextDouble();
             }
 
@@ -147,5 +145,5 @@
               for (int j = 0; j < arx[0].Length; j++)
                 sum += B[k, j] * artmp[j];
-              arx[i][k] = xmean[k] + sp.Sigma.Value * sum; // m + sig * Normal(0,C)
+              arx[i][k] = xmean[k] + sp.Sigma * sum; // m + sig * Normal(0,C)
               if (bounds[k % bounds.Rows, 0] > arx[i][k] || arx[i][k] > bounds[k % bounds.Rows, 1])
                 inRange = false;
Index: /branches/CMAES/HeuristicLab.Algorithms.CMAEvolutionStrategy/3.3/CMAOperators/CMARecombinator.cs
===================================================================
--- /branches/CMAES/HeuristicLab.Algorithms.CMAEvolutionStrategy/3.3/CMAOperators/CMARecombinator.cs	(revision 9296)
+++ /branches/CMAES/HeuristicLab.Algorithms.CMAEvolutionStrategy/3.3/CMAOperators/CMARecombinator.cs	(revision 9297)
@@ -22,5 +22,4 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
-using HeuristicLab.Data;
 using HeuristicLab.Encodings.RealVectorEncoding;
 using HeuristicLab.Operators;
@@ -72,10 +71,10 @@
     public override IOperation Apply() {
       var sp = StrategyParametersParameter.ActualValue;
-      if (sp.Weights == null) sp.Weights = GetWeights(sp.Mu.Value);
+      if (sp.Weights == null) sp.Weights = GetWeights(sp.Mu);
 
       var offspring = OffspringParameter.ActualValue;
       var mean = new RealVector(offspring[0].Length);
       for (int i = 0; i < mean.Length; i++) {
-        for (int j = 0; j < sp.Mu.Value; j++)
+        for (int j = 0; j < sp.Mu; j++)
           mean[i] += sp.Weights[j] * offspring[j][i];
       }
@@ -87,5 +86,5 @@
     }
 
-    protected abstract DoubleArray GetWeights(int mu);
+    protected abstract double[] GetWeights(int mu);
   }
 }
Index: /branches/CMAES/HeuristicLab.Algorithms.CMAEvolutionStrategy/3.3/CMAOperators/CMAUpdater.cs
===================================================================
--- /branches/CMAES/HeuristicLab.Algorithms.CMAEvolutionStrategy/3.3/CMAOperators/CMAUpdater.cs	(revision 9296)
+++ /branches/CMAES/HeuristicLab.Algorithms.CMAEvolutionStrategy/3.3/CMAOperators/CMAUpdater.cs	(revision 9297)
@@ -114,18 +114,18 @@
 
       #region Initialize default values for strategy parameter adjustment
-      if (sp.ChiN == null) sp.ChiN = new DoubleValue(Math.Sqrt(N) * (1.0 - 1.0 / (4.0 * N) + 1.0 / (21.0 * N * N)));
-      if (sp.MuEff == null) sp.MuEff = new DoubleValue(sp.Weights.Sum() * sp.Weights.Sum() / sp.Weights.Sum(x => x * x));
-      if (sp.CS == null) sp.CS = new DoubleValue((sp.MuEff.Value + 2) / (N + sp.MuEff.Value + 3));
-      if (sp.Damps == null) {
+      if (sp.ChiN == 0) sp.ChiN = Math.Sqrt(N) * (1.0 - 1.0 / (4.0 * N) + 1.0 / (21.0 * N * N));
+      if (sp.MuEff == 0) sp.MuEff = sp.Weights.Sum() * sp.Weights.Sum() / sp.Weights.Sum(x => x * x);
+      if (sp.CS == 0) sp.CS = (sp.MuEff + 2) / (N + sp.MuEff + 3);
+      if (sp.Damps == 0) {
         var maxIterations = MaximumIterationsParameter.ActualValue.Value;
         var maxEvals = MaximumEvaluatedSolutionsParameter.ActualValue.Value;
-        sp.Damps = new DoubleValue(2 * Math.Max(0, Math.Sqrt((sp.MuEff.Value - 1) / (N + 1)) - 1)
-                                * Math.Max(0.3, 1 - N / (1e-6 + Math.Min(maxIterations, maxEvals / lambda))) + sp.CS.Value + 1);
-      }
-      if (sp.CC == null) sp.CC = new DoubleValue(4.0 / (N + 4));
-      if (sp.MuCov == null) sp.MuCov = new DoubleValue(sp.MuEff.Value);
-      if (sp.CCov == null) sp.CCov = new DoubleValue(2.0 / ((N + 1.41) * (N + 1.41) * sp.MuCov.Value)
-                             + (1 - (1.0 / sp.MuCov.Value)) * Math.Min(1, (2 * sp.MuEff.Value - 1) / (sp.MuEff.Value + (N + 2) * (N + 2))));
-      if (sp.CCovSep == null) sp.CCovSep = new DoubleValue(Math.Min(1, sp.CCov.Value * (N + 1.5) / 3));
+        sp.Damps = 2 * Math.Max(0, Math.Sqrt((sp.MuEff - 1) / (N + 1)) - 1)
+                                * Math.Max(0.3, 1 - N / (1e-6 + Math.Min(maxIterations, maxEvals / lambda))) + sp.CS + 1;
+      }
+      if (sp.CC == 0) sp.CC = 4.0 / (N + 4);
+      if (sp.MuCov == 0) sp.MuCov = sp.MuEff;
+      if (sp.CCov == 0) sp.CCov = 2.0 / ((N + 1.41) * (N + 1.41) * sp.MuCov
+                             + (1 - (1.0 / sp.MuCov)) * Math.Min(1, (2 * sp.MuEff - 1) / (sp.MuEff + (N + 2) * (N + 2))));
+      if (sp.CCovSep == 0) sp.CCovSep = Math.Min(1, sp.CCov * (N + 1.5) / 3);
       #endregion
 
@@ -135,11 +135,11 @@
 
       for (int i = 0; i < N; i++) {
-        sp.BDz[i] = Math.Sqrt(sp.MuEff.Value) * (xmean[i] - xold[i]) / sp.Sigma.Value;
-      }
-
-      if (sp.InitialIterations.Value >= iterations) {
-        for (int i = 0; i < N; i++) {
-          sp.PS[i] = (1 - sp.CS.Value) * sp.PS[i]
-                     + Math.Sqrt(sp.CS.Value * (2 - sp.CS.Value)) * sp.BDz[i] / sp.D[i];
+        sp.BDz[i] = Math.Sqrt(sp.MuEff) * (xmean[i] - xold[i]) / sp.Sigma;
+      }
+
+      if (sp.InitialIterations >= iterations) {
+        for (int i = 0; i < N; i++) {
+          sp.PS[i] = (1 - sp.CS) * sp.PS[i]
+                     + Math.Sqrt(sp.CS * (2 - sp.CS)) * sp.BDz[i] / sp.D[i];
         }
       } else {
@@ -157,23 +157,23 @@
             sum += sp.B[i, j] * artmp[j];
           }
-          sp.PS[i] = (1 - sp.CS.Value) * sp.PS[i] + Math.Sqrt(sp.CS.Value * (2 - sp.CS.Value)) * sum;
+          sp.PS[i] = (1 - sp.CS) * sp.PS[i] + Math.Sqrt(sp.CS * (2 - sp.CS)) * sum;
         }
       }
       var normPS = Math.Sqrt(sp.PS.Select(x => x * x).Sum());
-      var hsig = normPS / Math.Sqrt(1 - Math.Pow(1 - sp.CS.Value, 2 * iterations)) / sp.ChiN.Value < 1.4 + 2.0 / (N + 1) ? 1.0 : 0.0;
+      var hsig = normPS / Math.Sqrt(1 - Math.Pow(1 - sp.CS, 2 * iterations)) / sp.ChiN < 1.4 + 2.0 / (N + 1) ? 1.0 : 0.0;
       for (int i = 0; i < sp.PC.Length; i++) {
-        sp.PC[i] = (1 - sp.CC.Value) * sp.PC[i]
-                   + hsig * Math.Sqrt(sp.CC.Value * (2 - sp.CC.Value)) * sp.BDz[i];
-      }
-
-      if (sp.CCov.Value > 0) {
-        if (sp.InitialIterations.Value >= iterations) {
+        sp.PC[i] = (1 - sp.CC) * sp.PC[i]
+                   + hsig * Math.Sqrt(sp.CC * (2 - sp.CC)) * sp.BDz[i];
+      }
+
+      if (sp.CCov > 0) {
+        if (sp.InitialIterations >= iterations) {
           for (int i = 0; i < N; i++) {
-            sp.C[i, i] = (1 - sp.CCovSep.Value) * sp.C[i, i]
-                         + sp.CCov.Value * (1 / sp.MuCov.Value)
-                         * (sp.PC[i] * sp.PC[i] + (1 - hsig) * sp.CC.Value * (2 - sp.CC.Value) * sp.C[i, i]);
-            for (int k = 0; k < sp.Mu.Value; k++) {
-              sp.C[i, i] += sp.CCov.Value * (1 - 1 / sp.MuCov.Value) * sp.Weights[k] * (offspring[k][i] - xold[i]) *
-                            (offspring[k][i] - xold[i]) / (sp.Sigma.Value * sp.Sigma.Value);
+            sp.C[i, i] = (1 - sp.CCovSep) * sp.C[i, i]
+                         + sp.CCov * (1 / sp.MuCov)
+                         * (sp.PC[i] * sp.PC[i] + (1 - hsig) * sp.CC * (2 - sp.CC) * sp.C[i, i]);
+            for (int k = 0; k < sp.Mu; k++) {
+              sp.C[i, i] += sp.CCov * (1 - 1 / sp.MuCov) * sp.Weights[k] * (offspring[k][i] - xold[i]) *
+                            (offspring[k][i] - xold[i]) / (sp.Sigma * sp.Sigma);
             }
           }
@@ -181,10 +181,10 @@
           for (int i = 0; i < N; i++) {
             for (int j = 0; j < N; j++) {
-              sp.C[i, j] = (1 - sp.CCov.Value) * sp.C[i, j]
-                           + sp.CCov.Value * (1 / sp.MuCov.Value)
-                           * (sp.PC[i] * sp.PC[j] + (1 - hsig) * sp.CC.Value * (2 - sp.CC.Value) * sp.C[i, j]);
-              for (int k = 0; k < sp.Mu.Value; k++) {
-                sp.C[i, j] += sp.CCov.Value * (1 - 1 / sp.MuCov.Value) * sp.Weights[k] * (offspring[k][i] - xold[i]) *
-                              (offspring[k][j] - xold[j]) / (sp.Sigma.Value * sp.Sigma.Value);
+              sp.C[i, j] = (1 - sp.CCov) * sp.C[i, j]
+                           + sp.CCov * (1 / sp.MuCov)
+                           * (sp.PC[i] * sp.PC[j] + (1 - hsig) * sp.CC * (2 - sp.CC) * sp.C[i, j]);
+              for (int k = 0; k < sp.Mu; k++) {
+                sp.C[i, j] += sp.CCov * (1 - 1 / sp.MuCov) * sp.Weights[k] * (offspring[k][i] - xold[i]) *
+                              (offspring[k][j] - xold[j]) / (sp.Sigma * sp.Sigma);
               }
             }
@@ -192,5 +192,5 @@
         }
       }
-      sp.Sigma.Value *= Math.Exp((sp.CS.Value / sp.Damps.Value) * (normPS / sp.ChiN.Value - 1));
+      sp.Sigma *= Math.Exp((sp.CS / sp.Damps) * (normPS / sp.ChiN - 1));
 
       double minSqrtdiagC = int.MaxValue, maxSqrtdiagC = int.MinValue;
@@ -201,12 +201,12 @@
 
       // ensure maximal and minimal standard deviations
-      if (sp.SigmaBounds != null && sp.SigmaBounds.Rows > 0) {
-        for (int i = 0; i < N; i++) {
-          var d = sp.SigmaBounds[Math.Min(i, sp.SigmaBounds.Rows - 1), 0];
-          if (d > sp.Sigma.Value * minSqrtdiagC) sp.Sigma.Value = d / minSqrtdiagC;
-        }
-        for (int i = 0; i < N; i++) {
-          var d = sp.SigmaBounds[Math.Min(i, sp.SigmaBounds.Rows - 1), 1];
-          if (d > sp.Sigma.Value * maxSqrtdiagC) sp.Sigma.Value = d / maxSqrtdiagC;
+      if (sp.SigmaBounds != null && sp.SigmaBounds.GetLength(0) > 0) {
+        for (int i = 0; i < N; i++) {
+          var d = sp.SigmaBounds[Math.Min(i, sp.SigmaBounds.GetLength(0) - 1), 0];
+          if (d > sp.Sigma * minSqrtdiagC) sp.Sigma = d / minSqrtdiagC;
+        }
+        for (int i = 0; i < N; i++) {
+          var d = sp.SigmaBounds[Math.Min(i, sp.SigmaBounds.GetLength(0) - 1), 1];
+          if (d > sp.Sigma * maxSqrtdiagC) sp.Sigma = d / maxSqrtdiagC;
         }
       }
@@ -221,5 +221,5 @@
 
       if (fac != 1.0) {
-        sp.Sigma.Value /= fac;
+        sp.Sigma /= fac;
         for (int i = 0; i < N; i++) {
           sp.PC[i] *= fac;
@@ -232,52 +232,47 @@
 
 
-      if (sp.InitialIterations.Value >= iterations) {
+      if (sp.InitialIterations >= iterations) {
         for (int i = 0; i < N; i++)
           sp.D[i] = Math.Sqrt(sp.C[i, i]);
         DegenerateStateParameter.ActualValue = new BoolValue(false);
       } else {
-        /*var c = new double[sp.C.Rows, sp.C.Columns];
-        for (int i = 0; i < sp.C.Rows; i++)
-          for (int j = 0; j < sp.C.Columns; j++)
-            c[i, j] = sp.C[i, j];
-
-        double[] eVal;
-        double[,] eVec;*/
 
         // set B <- C
-        for (int i = 0; i < N; ++i)
-          for (int j = 0; j <= i; ++j)
-            sp.B[i, j] = sp.B[j, i] = sp.C[i, j];
-
-        var success = Eigendecomposition(N, sp.B, sp.D); // alglib.smatrixevd(c, N, 1, false, out eVal, out eVec);
+        for (int i = 0; i < N; i++) {
+          for (int j = 0; j < N; j++) {
+            sp.B[i, j] = sp.C[i, j];
+          }
+        }
+        /*double[] eVal;
+        double[,] eVec;
+        var success = alglib.smatrixevd(sp.B, N, 1, false, out eVal, out eVec);
+        sp.B = eVec;
+        sp.D = eVal;*/
+        var success = Eigendecomposition(N, sp.B, sp.D);
+
         DegenerateStateParameter.ActualValue = new BoolValue(!success);
-        //sp.B = new DoubleMatrix(eVec);
-
-        /*for (int i = 0; i < sp.D.Length; i++) {
-          if (eVal[i] < 0) {
+
+        // assign D to eigenvalue square roots
+        for (int i = 0; i < N; i++) {
+          if (sp.D[i] < 0) { // numerical problem?
             DegenerateStateParameter.ActualValue.Value = true;
             sp.D[i] = 0;
-          } else sp.D[i] = Math.Sqrt(eVal[i]);
-        }*/
-
-        if (sp.D.Min() == 0.0) sp.AxisRatio.Value = double.PositiveInfinity;
-        else sp.AxisRatio.Value = sp.D.Max() / sp.D.Min();
+          } else sp.D[i] = Math.Sqrt(sp.D[i]);
+        }
+
+        if (sp.D.Min() == 0.0) sp.AxisRatio = double.PositiveInfinity;
+        else sp.AxisRatio = sp.D.Max() / sp.D.Min();
       }
       return base.Apply();
     }
 
-    private bool Eigendecomposition(int N, DoubleMatrix B, DoubleArray diagD) {
+    private bool Eigendecomposition(int N, double[,] B, double[] diagD) {
       bool result = true;
       // eigendecomposition
       var offdiag = new double[N];
-      tred2(N, B, diagD, offdiag);
-      tql2(N, diagD, offdiag, B);
-
-      // assign diagD to eigenvalue square roots
-      for (int i = 0; i < N; ++i) {
-        if (diagD[i] < 0) // numerical problem?
-          result = false;
-        else diagD[i] = Math.Sqrt(diagD[i]);
-      }
+      try {
+        tred2(N, B, diagD, offdiag);
+        tql2(N, diagD, offdiag, B);
+      } catch { result = false; }
 
       return result;
@@ -286,5 +281,5 @@
 
     // Symmetric Householder reduction to tridiagonal form, taken from JAMA package.
-    private void tred2(int n, DoubleMatrix V, DoubleArray d, double[] e) {
+    private void tred2(int n, double[,] V, double[] d, double[] e) {
 
       //  This is derived from the Algol procedures tred2 by
@@ -402,5 +397,5 @@
 
     // Symmetric tridiagonal QL algorithm, taken from JAMA package.
-    private void tql2(int n, DoubleArray d, double[] e, DoubleMatrix V) {
+    private void tql2(int n, double[] d, double[] e, double[,] V) {
 
       //  This is derived from the Algol procedures tql2, by
Index: /branches/CMAES/HeuristicLab.Algorithms.CMAEvolutionStrategy/3.3/CMAParameters.cs
===================================================================
--- /branches/CMAES/HeuristicLab.Algorithms.CMAEvolutionStrategy/3.3/CMAParameters.cs	(revision 9296)
+++ /branches/CMAES/HeuristicLab.Algorithms.CMAEvolutionStrategy/3.3/CMAParameters.cs	(revision 9297)
@@ -22,5 +22,4 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
-using HeuristicLab.Data;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 using System.Collections.Generic;
@@ -33,6 +32,6 @@
 
     [Storable]
-    private DoubleValue axisRatio;
-    public DoubleValue AxisRatio {
+    private double axisRatio;
+    public double AxisRatio {
       get { return axisRatio; }
       set {
@@ -44,6 +43,6 @@
 
     [Storable]
-    private DoubleValue sigma;
-    public DoubleValue Sigma {
+    private double sigma;
+    public double Sigma {
       get { return sigma; }
       set {
@@ -55,6 +54,6 @@
 
     [Storable]
-    private DoubleMatrix sigmaBounds;
-    public DoubleMatrix SigmaBounds {
+    private double[,] sigmaBounds;
+    public double[,] SigmaBounds {
       get { return sigmaBounds; }
       set {
@@ -66,6 +65,6 @@
 
     [Storable]
-    private IntValue mu;
-    public IntValue Mu {
+    private int mu;
+    public int Mu {
       get { return mu; }
       set {
@@ -77,6 +76,6 @@
 
     [Storable]
-    private DoubleArray weights;
-    public DoubleArray Weights {
+    private double[] weights;
+    public double[] Weights {
       get { return weights; }
       set {
@@ -88,6 +87,6 @@
 
     [Storable]
-    private DoubleValue muEff;
-    public DoubleValue MuEff {
+    private double muEff;
+    public double MuEff {
       get { return muEff; }
       set {
@@ -99,6 +98,6 @@
 
     [Storable]
-    private DoubleValue cc;
-    public DoubleValue CC {
+    private double cc;
+    public double CC {
       get { return cc; }
       set {
@@ -110,6 +109,6 @@
 
     [Storable]
-    private DoubleValue cs;
-    public DoubleValue CS {
+    private double cs;
+    public double CS {
       get { return cs; }
       set {
@@ -121,6 +120,6 @@
 
     [Storable]
-    private DoubleValue damps;
-    public DoubleValue Damps {
+    private double damps;
+    public double Damps {
       get { return damps; }
       set {
@@ -132,6 +131,6 @@
 
     [Storable]
-    private DoubleValue muCov;
-    public DoubleValue MuCov {
+    private double muCov;
+    public double MuCov {
       get { return muCov; }
       set {
@@ -143,6 +142,6 @@
 
     [Storable]
-    private DoubleValue cCov;
-    public DoubleValue CCov {
+    private double cCov;
+    public double CCov {
       get { return cCov; }
       set {
@@ -154,6 +153,6 @@
 
     [Storable]
-    private DoubleValue cCovSep;
-    public DoubleValue CCovSep {
+    private double cCovSep;
+    public double CCovSep {
       get { return cCovSep; }
       set {
@@ -165,6 +164,6 @@
 
     [Storable]
-    private DoubleArray pc;
-    public DoubleArray PC {
+    private double[] pc;
+    public double[] PC {
       get { return pc; }
       set {
@@ -176,6 +175,6 @@
 
     [Storable]
-    private DoubleArray ps;
-    public DoubleArray PS {
+    private double[] ps;
+    public double[] PS {
       get { return ps; }
       set {
@@ -187,6 +186,6 @@
 
     [Storable]
-    private DoubleMatrix b;
-    public DoubleMatrix B {
+    private double[,] b;
+    public double[,] B {
       get { return b; }
       set {
@@ -198,6 +197,6 @@
 
     [Storable]
-    private DoubleArray d;
-    public DoubleArray D {
+    private double[] d;
+    public double[] D {
       get { return d; }
       set {
@@ -209,6 +208,6 @@
 
     [Storable]
-    private DoubleMatrix c;
-    public DoubleMatrix C {
+    private double[,] c;
+    public double[,] C {
       get { return c; }
       set {
@@ -220,6 +219,6 @@
 
     [Storable]
-    private DoubleArray bDz;
-    public DoubleArray BDz {
+    private double[] bDz;
+    public double[] BDz {
       get { return bDz; }
       set {
@@ -231,6 +230,6 @@
 
     [Storable]
-    private DoubleValue chiN;
-    public DoubleValue ChiN {
+    private double chiN;
+    public double ChiN {
       get { return chiN; }
       set {
@@ -242,6 +241,6 @@
 
     [Storable]
-    private IntValue initialIterations;
-    public IntValue InitialIterations {
+    private int initialIterations;
+    public int InitialIterations {
       get { return initialIterations; }
       set {
@@ -275,24 +274,24 @@
     private CMAParameters(CMAParameters original, Cloner cloner)
       : base(original, cloner) {
-      this.axisRatio = cloner.Clone(original.axisRatio);
-      this.b = cloner.Clone(original.b);
-      this.bDz = cloner.Clone(original.bDz);
-      this.c = cloner.Clone(original.c);
-      this.cCov = cloner.Clone(original.cCov);
-      this.cCovSep = cloner.Clone(original.cCovSep);
-      this.cc = cloner.Clone(original.cc);
-      this.chiN = cloner.Clone(original.chiN);
-      this.cs = cloner.Clone(original.cs);
-      this.d = cloner.Clone(original.d);
-      this.damps = cloner.Clone(original.damps);
-      this.initialIterations = cloner.Clone(original.initialIterations);
-      this.mu = cloner.Clone(original.mu);
-      this.muCov = cloner.Clone(original.muCov);
-      this.muEff = cloner.Clone(original.muEff);
-      this.pc = cloner.Clone(original.pc);
-      this.ps = cloner.Clone(original.ps);
-      this.sigma = cloner.Clone(original.sigma);
-      this.sigmaBounds = cloner.Clone(original.sigmaBounds);
-      this.weights = cloner.Clone(original.weights);
+      this.axisRatio = original.axisRatio;
+      this.b = (double[,])original.b.Clone();
+      this.bDz = (double[])original.bDz.Clone();
+      this.c = (double[,])original.c.Clone();
+      this.cCov = original.cCov;
+      this.cCovSep = original.cCovSep;
+      this.cc = original.cc;
+      this.chiN = original.chiN;
+      this.cs = original.cs;
+      this.d = (double[])original.d.Clone();
+      this.damps = original.damps;
+      this.initialIterations = original.initialIterations;
+      this.mu = original.mu;
+      this.muCov = original.muCov;
+      this.muEff = original.muEff;
+      this.pc = (double[])original.pc.Clone();
+      this.ps = (double[])original.ps.Clone();
+      this.sigma = original.sigma;
+      this.sigmaBounds = (double[,])original.sigmaBounds.Clone();
+      this.weights = (double[])original.weights.Clone();
 
       this.qualityHistory = new Queue<double>(original.qualityHistory);
Index: /branches/CMAES/HeuristicLab.Algorithms.CMAEvolutionStrategy/3.3/Terminator.cs
===================================================================
--- /branches/CMAES/HeuristicLab.Algorithms.CMAEvolutionStrategy/3.3/Terminator.cs	(revision 9296)
+++ /branches/CMAES/HeuristicLab.Algorithms.CMAEvolutionStrategy/3.3/Terminator.cs	(revision 9297)
@@ -169,5 +169,5 @@
 
       double minSqrtdiagC = int.MaxValue, maxSqrtdiagC = int.MinValue;
-      for (int i = 0; i < sp.C.Rows; i++) {
+      for (int i = 0; i < sp.C.GetLength(0); i++) {
         if (Math.Sqrt(sp.C[i, i]) < minSqrtdiagC) minSqrtdiagC = Math.Sqrt(sp.C[i, i]);
         if (Math.Sqrt(sp.C[i, i]) > maxSqrtdiagC) maxSqrtdiagC = Math.Sqrt(sp.C[i, i]);
@@ -175,9 +175,9 @@
 
       var tolx = MinimumStandardDeviationParameter.ActualValue.Value;
-      if (sp.Sigma.Value * maxSqrtdiagC < tolx
-          && sp.Sigma.Value * sp.PC.Select(x => Math.Abs(x)).Max() < tolx) return terminateOp;
+      if (sp.Sigma * maxSqrtdiagC < tolx
+          && sp.Sigma * sp.PC.Select(x => Math.Abs(x)).Max() < tolx) return terminateOp;
 
       var stopTolUpXFactor = MaximumStandardDeviationChangeParameter.ActualValue.Value;
-      if (sp.Sigma.Value * maxSqrtdiagC > stopTolUpXFactor * InitialSigmaParameter.ActualValue.Max())
+      if (sp.Sigma * maxSqrtdiagC > stopTolUpXFactor * InitialSigmaParameter.ActualValue.Max())
         return terminateOp;
 
