Major bugfix for nonlinear GenSVM

Nonlinear GenSVM depends on the eigendecomposition of the
kernel matrix. Mathematically, the Sigma vector in the code
should contain the square root of the eigenvalues. Taking
the square root was however neglected, which resulted in
poor performance of nonlinear GenSVM. This is now fixed,
which means that the performance of nonlinear GenSVM will
be much better.

9 files changed, 182 insertions, 149 deletions

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 81713d4..5f3bcc4 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,9 @@
 # Change Log
 
+## Version 0.2.0
+
+- Fix bug in nonlinear GenSVM, it should perform better now.
+
 ## Version 0.1.4
 
 - Keep track of elapsed iterations during training
diff --git a/Makefile b/Makefile
index 07855ae..15ff02a 100644
--- a/Makefile
+++ b/Makefile
@@ -1,4 +1,4 @@
-VERSION=0.1.4
+VERSION=0.2.0
 CC=gcc
 CFLAGS=-Wall -Wno-unused-result -Wsign-compare -Wstrict-prototypes \
        -DVERSION=$(VERSION) -g -O3
diff --git a/src/gensvm_kernel.c b/src/gensvm_kernel.c
index 521bddb..190a120 100644
--- a/src/gensvm_kernel.c
+++ b/src/gensvm_kernel.c
@@ -264,9 +264,12 @@ long gensvm_kernel_eigendecomp(double *K, long n, double cutoff, double **P_ret,
 
 	num_eigen = n - cutoff_idx;
 
+	// In the mathematical derivation (see paper), we state that the 
+	// diagonal matrix Sigma contains the square root of the eigenvalues 
+	// (i.e. the eigendecomposition is: K = P * Sigma^2 * P').
 	Sigma = Calloc(double, num_eigen);
 	for (i=0; i<num_eigen; i++) {
-		Sigma[i] = tempSigma[n-1 - i];
+		Sigma[i] = sqrt(tempSigma[n-1 - i]);
 	}
 
 	// revert P to row-major order and copy only the the columns
diff --git a/tests/aux/test_eigendecomp.m b/tests/aux/test_eigendecomp.m
index 921f44b..f3ff4ab 100644
--- a/tests/aux/test_eigendecomp.m
+++ b/tests/aux/test_eigendecomp.m
@@ -23,7 +23,7 @@ ratios = eigenvalues ./ eigenvalues(end, end);
 cutoff = 1e-2;
 
 realP = fliplr(P(:, ratios > cutoff));
-realSigma = flipud(eigenvalues(ratios > cutoff));
+realSigma = sqrt(flipud(eigenvalues(ratios > cutoff)));
 
 r = sum(ratios > cutoff);
 
diff --git a/tests/aux/test_kernel_pre.m b/tests/aux/test_kernel_pre.m
index a1c8337..69f6f1e 100644
--- a/tests/aux/test_kernel_pre.m
+++ b/tests/aux/test_kernel_pre.m
@@ -1,32 +1,32 @@
 function test_kernel_pre()
-  
+
   kerneltype = 'rbf';
   rand('state', 123456);
   n = 10;
   m = 5;
   cutoff = 5e-3;
-  
+
   X = rand(n, m);
   Z = [ones(n, 1), X];
-  
+
   set_matrix(Z, "data->Z", "data->m+1");
-  
+
   K = zeros(n, n);
   if strcmp(kerneltype, 'poly')
-    # Polynomial kernel
-    # (gamma * <x_1, x_2> + c)^d
+    % Polynomial kernel
+    % (gamma * <x_1, x_2> + c)^d
     gamma = 1.5;
     c = 3.0;
     d = 1.78;
-    
+
     for ii=1:n
       for jj=1:n
         K(ii, jj) = (gamma * (X(ii, :) * X(jj, :)') + c)^d;
       end
     end
   elseif strcmp(kerneltype, 'rbf')
-    # RBF kernel
-    # exp(-gamma * norm(x1 - x2)^2)
+    % RBF kernel
+    % exp(-gamma * norm(x1 - x2)^2)
     gamma = 0.348
     for ii=1:n
       for jj=1:n
@@ -34,8 +34,8 @@ function test_kernel_pre()
       end
     end
   elseif strcmp(kerneltype, 'sigmoid')
-    # Sigmoid kernel
-    # tanh(gamma * <x_1, x_2> + c)
+    % Sigmoid kernel
+    % tanh(gamma * <x_1, x_2> + c)
     gamma = 1.23;
     c = 1.6;
     for ii=1:n
@@ -44,29 +44,27 @@ function test_kernel_pre()
       end
     end
   end
-  
-  K(1, 2)
 
-  [P, Sigma] = eig(K);
+  [P, values] = eig(K);
 
-  eigenvalues = diag(Sigma);
+  eigenvalues = diag(values);
   ratios = eigenvalues ./ eigenvalues(end, end);
- 
+
   realP = fliplr(P(:, ratios > cutoff));
-  realSigma = flipud(eigenvalues(ratios > cutoff));
-  
+  realSigma = sqrt(flipud(eigenvalues(ratios > cutoff)));
+
   assert_matrix(realSigma, "data->Sigma", "1");
-  
+
   r = sum(ratios > cutoff);
   fprintf("mu_assert(data->r == %i);\n", r);
-  
+
   M = realP * diag(realSigma);
-  
+
   newZ = [ones(n, 1) M];
   assert_matrix_abs(newZ, "data->Z", "data->r+1");
-  
+
   assert_matrix(Z, "data->RAW", "data->m+1");
-  
+
 end
 
 function set_matrix(A, name, cols)
@@ -98,4 +96,4 @@ function assert_matrix_abs(A, name, cols)
     end
   end
   fprintf("\n");
-end
\ No newline at end of file
+end
diff --git a/tests/aux/test_train_kernel.m b/tests/aux/test_train_kernel.m
index 7bf14b8..b561bd4 100644
--- a/tests/aux/test_train_kernel.m
+++ b/tests/aux/test_train_kernel.m
@@ -1,21 +1,21 @@
 function [V] = test_train_kernel()
-  
+
   clear;
   more off;
   rand('state', 654321);
-  
+
   n = 10;
   m = 5;
   classes = 4;
   cutoff = 5e-3;
-  
+
   X = rand(n, m);
   Z = [ones(n, 1), X];
   set_matrix(Z, "data->Z", "data->m+1");
-  
+
   y = [2 1 3 2 3 2 4 1 3 4];
   set_matrix(y, "data->y", "1");
-  
+
   p = 1.2143;
   kappa = 0.90298;
   lambda = 0.00219038;
@@ -36,24 +36,24 @@ function [V] = test_train_kernel()
 
   eigenvalues = diag(Sigma);
   ratios = eigenvalues ./ eigenvalues(end, end);
- 
+
   realP = fliplr(P(:, ratios > cutoff));
-  realSigma = flipud(eigenvalues(ratios > cutoff));
-  
+  realSigma = sqrt(flipud(eigenvalues(ratios > cutoff)));
+
   assert_matrix(realSigma, "data->Sigma", "1");
-  
+
   r = sum(ratios > cutoff);
   fprintf("mu_assert(data->r == %i);\n", r);
-  
+
   M = realP * diag(realSigma);
   size(M)
-  
+
   assert_matrix(Z, "data->RAW", "data->m+1");
-  
-  seedV = zeros(size(M, 2) + 1, classes - 1);  
+
+  seedV = zeros(size(M, 2) + 1, classes - 1);
   [W, t] = msvmmaj(M, y, rho, p, kappa, lambda, epsilon, 'show', 0, seedV);
   V = [t'; W];
-  
+
   fprintf('\n');
   assert_matrix_abs(V, "model->V", "model->K-1");
 
@@ -89,4 +89,4 @@ function assert_matrix_abs(A, name, cols)
     end
   end
   fprintf("\n");
-end
\ No newline at end of file
+end
diff --git a/tests/src/test_gensvm_io.c b/tests/src/test_gensvm_io.c
index bf9746f..b4210bb 100644
--- a/tests/src/test_gensvm_io.c
+++ b/tests/src/test_gensvm_io.c
@@ -654,7 +654,7 @@ char *test_gensvm_write_model()
 	char buffer[GENSVM_MAX_LINE_LENGTH];
 
 	fgets(buffer, GENSVM_MAX_LINE_LENGTH, fid);
-	mu_assert(strcmp(buffer, "Output file for GenSVM (version 0.1.4)\n")
+	mu_assert(strcmp(buffer, "Output file for GenSVM (version 0.2.0)\n")
 			== 0, "Line doesn't contain expected content (0).\n");
 
 	// skip the time line
diff --git a/tests/src/test_gensvm_kernel.c b/tests/src/test_gensvm_kernel.c
index cf1d4db..b075bc5 100644
--- a/tests/src/test_gensvm_kernel.c
+++ b/tests/src/test_gensvm_kernel.c
@@ -326,245 +326,269 @@ char *test_kernel_preprocess_kernel()
 	mu_assert(data->r == 7, "Incorrect data->r");
 
 	double eps = 1e-14;
+
+	mu_assert(fabs(matrix_get(data->Sigma, 1, 0, 0) -
+				2.7638223432435374) < eps,
+			"Incorrect data->Sigma at 0, 0");
+	mu_assert(fabs(matrix_get(data->Sigma, 1, 1, 0) -
+				0.8989108618424078) < eps,
+			"Incorrect data->Sigma at 1, 0");
+	mu_assert(fabs(matrix_get(data->Sigma, 1, 2, 0) -
+				0.8492992522024180) < eps,
+			"Incorrect data->Sigma at 2, 0");
+	mu_assert(fabs(matrix_get(data->Sigma, 1, 3, 0) -
+				0.6551312398422764) < eps,
+			"Incorrect data->Sigma at 3, 0");
+	mu_assert(fabs(matrix_get(data->Sigma, 1, 4, 0) -
+				0.4151267289513675) < eps,
+			"Incorrect data->Sigma at 4, 0");
+	mu_assert(fabs(matrix_get(data->Sigma, 1, 5, 0) -
+				0.3219015071458272) < eps,
+			"Incorrect data->Sigma at 5, 0");
+	mu_assert(fabs(matrix_get(data->Sigma, 1, 6, 0) -
+				0.2206142024294812) < eps,
+			"Incorrect data->Sigma at 6, 0");
+
+
 	mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 0, 0)) -
 				fabs(1.0000000000000000)) < eps,
 			"Incorrect data->Z at 0, 0");
 	mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 0, 1)) -
-				fabs(2.4632837902141640)) < eps,
+				fabs(0.8912598149573278)) < eps,
 			"Incorrect data->Z at 0, 1");
 	mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 0, 2)) -
-				fabs(-0.3037489220604925)) < eps,
+				fabs(-0.3379077225053534)) < eps,
 			"Incorrect data->Z at 0, 2");
 	mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 0, 3)) -
-				fabs(-0.0061287029147240)) < eps,
+				fabs(-0.0072161878146390)) < eps,
 			"Incorrect data->Z at 0, 3");
 	mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 0, 4)) -
-				fabs(0.1822712619914593)) < eps,
+				fabs(0.2782209897902920)) < eps,
 			"Incorrect data->Z at 0, 4");
 	mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 0, 5)) -
-				fabs(0.0252737053303148)) < eps,
+				fabs(0.0608819032061786)) < eps,
 			"Incorrect data->Z at 0, 5");
 	mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 0, 6)) -
-				fabs(-0.0078753266252524)) < eps,
+				fabs(-0.0244650194249782)) < eps,
 			"Incorrect data->Z at 0, 6");
 	mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 0, 7)) -
-				fabs(-0.0012800124996018)) < eps,
+				fabs(-0.0058020403287988)) < eps,
 			"Incorrect data->Z at 0, 7");
 	mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 1, 0)) -
 				fabs(1.0000000000000000)) < eps,
 			"Incorrect data->Z at 1, 0");
 	mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 1, 1)) -
-				fabs(2.2923640983040641)) < eps,
+				fabs(0.8294180354638190)) < eps,
 			"Incorrect data->Z at 1, 1");
 	mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 1, 2)) -
-				fabs(-0.3048037728463330)) < eps,
+				fabs(-0.3390811990207864)) < eps,
 			"Incorrect data->Z at 1, 2");
 	mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 1, 3)) -
-				fabs(-0.2586192720897897)) < eps,
+				fabs(-0.3045090071834334)) < eps,
 			"Incorrect data->Z at 1, 3");
 	mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 1, 4)) -
-				fabs(0.1747912247100736)) < eps,
+				fabs(0.2668033732480146)) < eps,
 			"Incorrect data->Z at 1, 4");
 	mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 1, 5)) -
-				fabs(-0.0623497873850738)) < eps,
+				fabs(-0.1501945864641692)) < eps,
 			"Incorrect data->Z at 1, 5");
 	mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 1, 6)) -
-				fabs(-0.0199493291395259)) < eps,
+				fabs(-0.0619733946461100)) < eps,
 			"Incorrect data->Z at 1, 6");
 	mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 1, 7)) -
-				fabs(0.0068540206892510)) < eps,
+				fabs(0.0310679032164383)) < eps,
 			"Incorrect data->Z at 1, 7");
 	mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 2, 0)) -
 				fabs(1.0000000000000000)) < eps,
 			"Incorrect data->Z at 2, 0");
 	mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 2, 1)) -
-				fabs(2.4167201742337761)) < eps,
+				fabs(0.8744122718819858)) < eps,
 			"Incorrect data->Z at 2, 1");
 	mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 2, 2)) -
-				fabs(-0.1499385272847361)) < eps,
+				fabs(-0.1668002175181436)) < eps,
 			"Incorrect data->Z at 2, 2");
 	mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 2, 3)) -
-				fabs(-0.1781619658696836)) < eps,
+				fabs(-0.2097752534311912)) < eps,
 			"Incorrect data->Z at 2, 3");
 	mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 2, 4)) -
-				fabs(-0.2363293887681946)) < eps,
+				fabs(-0.3607359478462531)) < eps,
 			"Incorrect data->Z at 2, 4");
 	mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 2, 5)) -
-				fabs(-0.0362117307160720)) < eps,
+				fabs(-0.0872305447725448)) < eps,
 			"Incorrect data->Z at 2, 5");
 	mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 2, 6)) -
-				fabs(0.0366137533260933)) < eps,
+				fabs(0.1137420997209145)) < eps,
 			"Incorrect data->Z at 2, 6");
 	mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 2, 7)) -
-				fabs(0.0227049982868101)) < eps,
+				fabs(0.1029172103916005)) < eps,
 			"Incorrect data->Z at 2, 7");
 	mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 3, 0)) -
 				fabs(1.0000000000000000)) < eps,
 			"Incorrect data->Z at 3, 0");
 	mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 3, 1)) -
-				fabs(2.3339314848494390)) < eps,
+				fabs(0.8444578540132961)) < eps,
 			"Incorrect data->Z at 3, 1");
 	mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 3, 2)) -
-				fabs(0.4067278927345656)) < eps,
+				fabs(0.4524674358711562)) < eps,
 			"Incorrect data->Z at 3, 2");
 	mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 3, 3)) -
-				fabs(0.0198947146890620)) < eps,
+				fabs(0.0234248583611390)) < eps,
 			"Incorrect data->Z at 3, 3");
 	mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 3, 4)) -
-				fabs(0.1187106614859180)) < eps,
+				fabs(0.1812013445038858)) < eps,
 			"Incorrect data->Z at 3, 4");
 	mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 3, 5)) -
-				fabs(0.0734848412140159)) < eps,
+				fabs(0.1770178504276099)) < eps,
 			"Incorrect data->Z at 3, 5");
 	mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 3, 6)) -
-				fabs(-0.0166955533210990)) < eps,
+				fabs(-0.0518654089852882)) < eps,
 			"Incorrect data->Z at 3, 6");
 	mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 3, 7)) -
-				fabs(0.0229112619510384)) < eps,
+				fabs(0.1038521622757349)) < eps,
 			"Incorrect data->Z at 3, 7");
 	mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 4, 0)) -
 				fabs(1.0000000000000000)) < eps,
 			"Incorrect data->Z at 4, 0");
 	mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 4, 1)) -
-				fabs(2.5061509421266424)) < eps,
+				fabs(0.9067699116960968)) < eps,
 			"Incorrect data->Z at 4, 1");
 	mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 4, 2)) -
-				fabs(0.0574469229922174)) < eps,
+				fabs(0.0639072520210456)) < eps,
 			"Incorrect data->Z at 4, 2");
 	mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 4, 3)) -
-				fabs(-0.2858649955147738)) < eps,
+				fabs(-0.3365892466918618)) < eps,
 			"Incorrect data->Z at 4, 3");
 	mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 4, 4)) -
-				fabs(-0.0995031375002134)) < eps,
+				fabs(-0.1518827548571320)) < eps,
 			"Incorrect data->Z at 4, 4");
 	mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 4, 5)) -
-				fabs(0.0223790101651578)) < eps,
+				fabs(0.0539088634973914)) < eps,
 			"Incorrect data->Z at 4, 5");
 	mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 4, 6)) -
-				fabs(-0.0355571480867735)) < eps,
+				fabs(-0.1104597129788070)) < eps,
 			"Incorrect data->Z at 4, 6");
 	mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 4, 7)) -
-				fabs(-0.0219026472149696)) < eps,
+				fabs(-0.0992803136596373)) < eps,
 			"Incorrect data->Z at 4, 7");
 	mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 5, 0)) -
 				fabs(1.0000000000000000)) < eps,
 			"Incorrect data->Z at 5, 0");
 	mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 5, 1)) -
-				fabs(2.4482858151168982)) < eps,
+				fabs(0.8858332812534048)) < eps,
 			"Incorrect data->Z at 5, 1");
 	mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 5, 2)) -
-				fabs(-0.0670998214520230)) < eps,
+				fabs(-0.0746456899124524)) < eps,
 			"Incorrect data->Z at 5, 2");
 	mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 5, 3)) -
-				fabs(0.3147064295566219)) < eps,
+				fabs(0.3705483417541217)) < eps,
 			"Incorrect data->Z at 5, 3");
 	mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 5, 4)) -
-				fabs(0.1070535630418465)) < eps,
+				fabs(0.1634078128645188)) < eps,
 			"Incorrect data->Z at 5, 4");
 	mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 5, 5)) -
-				fabs(-0.0052824396955993)) < eps,
+				fabs(-0.0127248845405431)) < eps,
 			"Incorrect data->Z at 5, 5");
 	mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 5, 6)) -
-				fabs(0.0614363461130733)) < eps,
+				fabs(0.1908544842110400)) < eps,
 			"Incorrect data->Z at 5, 6");
 	mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 5, 7)) -
-				fabs(-0.0075355247061472)) < eps,
+				fabs(-0.0341570244488496)) < eps,
 			"Incorrect data->Z at 5, 7");
 	mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 6, 0)) -
 				fabs(1.0000000000000000)) < eps,
 			"Incorrect data->Z at 6, 0");
 	mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 6, 1)) -
-				fabs(2.3638928644404329)) < eps,
+				fabs(0.8552984131629242)) < eps,
 			"Incorrect data->Z at 6, 1");
 	mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 6, 2)) -
-				fabs(0.3482541374011597)) < eps,
+				fabs(0.3874178766595150)) < eps,
 			"Incorrect data->Z at 6, 2");
 	mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 6, 3)) -
-				fabs(-0.2422541976251498)) < eps,
+				fabs(-0.2852400929318269)) < eps,
 			"Incorrect data->Z at 6, 3");
 	mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 6, 4)) -
-				fabs(0.0251886519764033)) < eps,
+				fabs(0.0384482534865339)) < eps,
 			"Incorrect data->Z at 6, 4");
 	mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 6, 5)) -
-				fabs(-0.0079397861684362)) < eps,
+				fabs(-0.0191261742853618)) < eps,
 			"Incorrect data->Z at 6, 5");
 	mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 6, 6)) -
-				fabs(0.0424975213407462)) < eps,
+				fabs(0.1320202620905840)) < eps,
 			"Incorrect data->Z at 6, 6");
 	mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 6, 7)) -
-				fabs(-0.0204279932276333)) < eps,
+				fabs(-0.0925960024453241)) < eps,
 			"Incorrect data->Z at 6, 7");
 	mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 7, 0)) -
 				fabs(1.0000000000000000)) < eps,
 			"Incorrect data->Z at 7, 0");
 	mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 7, 1)) -
-				fabs(2.3607306299135344)) < eps,
+				fabs(0.8541542605604135)) < eps,
 			"Incorrect data->Z at 7, 1");
 	mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 7, 2)) -
-				fabs(-0.0220102589508912)) < eps,
+				fabs(-0.0244854744615944)) < eps,
 			"Incorrect data->Z at 7, 2");
 	mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 7, 3)) -
-				fabs(0.3913398731540265)) < eps,
+				fabs(0.4607797217991149)) < eps,
 			"Incorrect data->Z at 7, 3");
 	mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 7, 4)) -
-				fabs(-0.0941469673695446)) < eps,
+				fabs(-0.1437070340168947)) < eps,
 			"Incorrect data->Z at 7, 4");
 	mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 7, 5)) -
-				fabs(-0.0477595489009114)) < eps,
+				fabs(-0.1150481180085769)) < eps,
 			"Incorrect data->Z at 7, 5");
 	mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 7, 6)) -
-				fabs(-0.0367688438245860)) < eps,
+				fabs(-0.1142238946024231)) < eps,
 			"Incorrect data->Z at 7, 6");
 	mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 7, 7)) -
-				fabs(-0.0133498576642393)) < eps,
+				fabs(-0.0605122313850435)) < eps,
 			"Incorrect data->Z at 7, 7");
 	mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 8, 0)) -
 				fabs(1.0000000000000000)) < eps,
 			"Incorrect data->Z at 8, 0");
 	mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 8, 1)) -
-				fabs(2.5023932475093376)) < eps,
+				fabs(0.9054103110595034)) < eps,
 			"Incorrect data->Z at 8, 1");
 	mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 8, 2)) -
-				fabs(0.2929602950386334)) < eps,
+				fabs(0.3259058350214859)) < eps,
 			"Incorrect data->Z at 8, 2");
 	mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 8, 3)) -
-				fabs(0.1371647327912284)) < eps,
+				fabs(0.1615034187720415)) < eps,
 			"Incorrect data->Z at 8, 3");
 	mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 8, 4)) -
-				fabs(-0.0270505649533715)) < eps,
+				fabs(-0.0412902992687150)) < eps,
 			"Incorrect data->Z at 8, 4");
 	mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 8, 5)) -
-				fabs(-0.0685258491091892)) < eps,
+				fabs(-0.1650721197410958)) < eps,
 			"Incorrect data->Z at 8, 5");
 	mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 8, 6)) -
-				fabs(-0.0213385621647371)) < eps,
+				fabs(-0.0662891030052566)) < eps,
 			"Incorrect data->Z at 8, 6");
 	mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 8, 7)) -
-				fabs(0.0121305554343051)) < eps,
+				fabs(0.0549853785509707)) < eps,
 			"Incorrect data->Z at 8, 7");
 	mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 9, 0)) -
 				fabs(1.0000000000000000)) < eps,
 			"Incorrect data->Z at 9, 0");
 	mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 9, 1)) -
-				fabs(2.4579608302226870)) < eps,
+				fabs(0.8893338735144964)) < eps,
 			"Incorrect data->Z at 9, 1");
 	mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 9, 2)) -
-				fabs(-0.2538863526247282)) < eps,
+				fabs(-0.2824377403832496)) < eps,
 			"Incorrect data->Z at 9, 2");
 	mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 9, 3)) -
-				fabs(0.0991005899665861)) < eps,
+				fabs(0.1166851256604740)) < eps,
 			"Incorrect data->Z at 9, 3");
 	mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 9, 4)) -
-				fabs(-0.1374781282330359)) < eps,
+				fabs(-0.2098482256259584)) < eps,
 			"Incorrect data->Z at 9, 4");
 	mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 9, 5)) -
-				fabs(0.1043628273525485)) < eps,
+				fabs(0.2513999221784036)) < eps,
 			"Incorrect data->Z at 9, 5");
 	mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 9, 6)) -
-				fabs(-0.0024213407513349)) < eps,
+				fabs(-0.0075219925896089)) < eps,
 			"Incorrect data->Z at 9, 6");
 	mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 9, 7)) -
-				fabs(0.0007673936590348)) < eps,
+				fabs(0.0034784417801946)) < eps,
 			"Incorrect data->Z at 9, 7");
 
 	mu_assert(fabs(matrix_get(data->RAW, data->m+1, 0, 0) -
@@ -748,9 +772,9 @@ char *test_kernel_preprocess_kernel()
 				0.1028774221216107) < eps,
 			"Incorrect data->RAW at 9, 5");
 
-	// end test code //
 
 
+	// end test code //
 
 	gensvm_free_model(model);
 	gensvm_free_data(data);
@@ -2317,7 +2341,7 @@ char *test_kernel_eigendecomp()
 
 	mu_assert(r == 7, "Incorrect number of eigenvalues kept");
 
-	// Note: to overcome sign variability in the eigenvectors, we take the 
+	// Note: to overcome sign variability in the eigenvectors, we take the
 	// absolute value of the elements of P and the expected outcome.
 
 	mu_assert(fabs(fabs(matrix_get(P, r, 0, 0)) -
@@ -2532,19 +2556,20 @@ char *test_kernel_eigendecomp()
 			"Incorrect P at 9, 6");
 
 	eps = 1e-13;
-	mu_assert(fabs(Sigma[0] - 22.9663721202447704) < eps,
+
+	mu_assert(fabs(Sigma[0] - 4.7923242920575353) < eps,
 			"Incorrect Sigma at 0");
-	mu_assert(fabs(Sigma[1] - 2.2569857335186856) < eps,
+	mu_assert(fabs(Sigma[1] - 1.5023267732150303) < eps,
 			"Incorrect Sigma at 1");
-	mu_assert(fabs(Sigma[2] - 1.4177404640754938) < eps,
+	mu_assert(fabs(Sigma[2] - 1.1906890711161726) < eps,
 			"Incorrect Sigma at 2");
-	mu_assert(fabs(Sigma[3] - 1.0075496644459232) < eps,
+	mu_assert(fabs(Sigma[3] - 1.0037677343120393) < eps,
 			"Incorrect Sigma at 3");
-	mu_assert(fabs(Sigma[4] - 0.7919296491505164) < eps,
+	mu_assert(fabs(Sigma[4] - 0.8899042921295091) < eps,
 			"Incorrect Sigma at 4");
-	mu_assert(fabs(Sigma[5] - 0.6808726728950240) < eps,
+	mu_assert(fabs(Sigma[5] - 0.8251500911319253) < eps,
 			"Incorrect Sigma at 5");
-	mu_assert(fabs(Sigma[6] - 0.2909718164349679) < eps,
+	mu_assert(fabs(Sigma[6] - 0.5394180349552358) < eps,
 			"Incorrect Sigma at 6");
 
 	// end test code //
diff --git a/tests/src/test_gensvm_train.c b/tests/src/test_gensvm_train.c
index b95de28..f7033f0 100644
--- a/tests/src/test_gensvm_train.c
+++ b/tests/src/test_gensvm_train.c
@@ -275,23 +275,24 @@ char *test_gensvm_train_seed_kernel()
 	mu_assert(model->K == data->K, "Incorrect model K");
 
 	double eps = 1e-13;
+
 	mu_assert(fabs(matrix_get(data->Sigma, 1, 0, 0) -
-				7.8302939172918506) < eps,
+				2.7982662341692670) < eps,
 			"Incorrect data->Sigma at 0, 0");
 	mu_assert(fabs(matrix_get(data->Sigma, 1, 1, 0) -
-				0.7947913383766066) < eps,
+				0.8915107056993801) < eps,
 			"Incorrect data->Sigma at 1, 0");
 	mu_assert(fabs(matrix_get(data->Sigma, 1, 2, 0) -
-				0.5288740088908547) < eps,
+				0.7272372438832145) < eps,
 			"Incorrect data->Sigma at 2, 0");
 	mu_assert(fabs(matrix_get(data->Sigma, 1, 3, 0) -
-				0.4537982052555444) < eps,
+				0.6736454596117636) < eps,
 			"Incorrect data->Sigma at 3, 0");
 	mu_assert(fabs(matrix_get(data->Sigma, 1, 4, 0) -
-				0.2226012271232192) < eps,
+				0.4718063449374322) < eps,
 			"Incorrect data->Sigma at 4, 0");
 	mu_assert(fabs(matrix_get(data->Sigma, 1, 5, 0) -
-				0.0743004417495061) < eps,
+				0.2725810737184557) < eps,
 			"Incorrect data->Sigma at 5, 0");
 
 	// we need a large eps here because there are numerical precision 
@@ -299,69 +300,71 @@ char *test_gensvm_train_seed_kernel()
 	// compare with absolute values because of variability in the 
 	// eigendecomposition.
 	eps = 1e-7;
+
 	mu_assert(fabs(fabs(matrix_get(model->V, model->K-1, 0, 0)) -
-				fabs(5.0555413160638665)) < eps,
+				fabs(1.3968329665264863)) < eps,
 			"Incorrect model->V at 0, 0");
 	mu_assert(fabs(fabs(matrix_get(model->V, model->K-1, 0, 1)) -
-				fabs(-2.2586632211763198)) < eps,
+				fabs(-0.4491223112772532)) < eps,
 			"Incorrect model->V at 0, 1");
 	mu_assert(fabs(fabs(matrix_get(model->V, model->K-1, 0, 2)) -
-				fabs(-4.5572671806963143)) < eps,
+				fabs(-1.2044427235549637)) < eps,
 			"Incorrect model->V at 0, 2");
 	mu_assert(fabs(fabs(matrix_get(model->V, model->K-1, 1, 0)) -
-				fabs(-1.9627432869558412)) < eps,
+				fabs(-1.2834234211019704)) < eps,
 			"Incorrect model->V at 1, 0");
 	mu_assert(fabs(fabs(matrix_get(model->V, model->K-1, 1, 1)) -
-				fabs(0.9934555242449399)) < eps,
+				fabs(0.6330939040375793)) < eps,
 			"Incorrect model->V at 1, 1");
 	mu_assert(fabs(fabs(matrix_get(model->V, model->K-1, 1, 2)) -
-				fabs(1.7855287218670219)) < eps,
+				fabs(1.2876548429115076)) < eps,
 			"Incorrect model->V at 1, 2");
 	mu_assert(fabs(fabs(matrix_get(model->V, model->K-1, 2, 0)) -
-				fabs(1.9393083227054353)) < eps,
+				fabs(2.0023377286211428)) < eps,
 			"Incorrect model->V at 2, 0");
 	mu_assert(fabs(fabs(matrix_get(model->V, model->K-1, 2, 1)) -
-				fabs(-1.1958487809502740)) < eps,
+				fabs(-1.5454495147993872)) < eps,
 			"Incorrect model->V at 2, 1");
 	mu_assert(fabs(fabs(matrix_get(model->V, model->K-1, 2, 2)) -
-				fabs(2.1140967864804359)) < eps,
+				fabs(1.8380262406111434)) < eps,
 			"Incorrect model->V at 2, 2");
 	mu_assert(fabs(fabs(matrix_get(model->V, model->K-1, 3, 0)) -
-				fabs(2.3909204618652535)) < eps,
+				fabs(1.8873525552961188)) < eps,
 			"Incorrect model->V at 3, 0");
 	mu_assert(fabs(fabs(matrix_get(model->V, model->K-1, 3, 1)) -
-				fabs(-0.2834554569573399)) < eps,
+				fabs(-0.5671111794102348)) < eps,
 			"Incorrect model->V at 3, 1");
 	mu_assert(fabs(fabs(matrix_get(model->V, model->K-1, 3, 2)) -
-				fabs(1.0926232371314393)) < eps,
+				fabs(1.3530484176263944)) < eps,
 			"Incorrect model->V at 3, 2");
 	mu_assert(fabs(fabs(matrix_get(model->V, model->K-1, 4, 0)) -
-				fabs(3.3374545494113272)) < eps,
+				fabs(2.9991675684385952)) < eps,
 			"Incorrect model->V at 4, 0");
 	mu_assert(fabs(fabs(matrix_get(model->V, model->K-1, 4, 1)) -
-				fabs(1.6699291195221897)) < eps,
+				fabs(1.6232323178615611)) < eps,
 			"Incorrect model->V at 4, 1");
 	mu_assert(fabs(fabs(matrix_get(model->V, model->K-1, 4, 2)) -
-				fabs(-1.4345249893609275)) < eps,
+				fabs(-1.0853101351516645)) < eps,
 			"Incorrect model->V at 4, 2");
 	mu_assert(fabs(fabs(matrix_get(model->V, model->K-1, 5, 0)) -
-				fabs(-0.0221825925355533)) < eps,
+				fabs(-0.2735156994082831)) < eps,
 			"Incorrect model->V at 5, 0");
 	mu_assert(fabs(fabs(matrix_get(model->V, model->K-1, 5, 1)) -
-				fabs(-0.1216077739550210)) < eps,
+				fabs(-0.2154874773946488)) < eps,
 			"Incorrect model->V at 5, 1");
 	mu_assert(fabs(fabs(matrix_get(model->V, model->K-1, 5, 2)) -
-				fabs(-0.7900947982642630)) < eps,
+				fabs(-0.9036193937904904)) < eps,
 			"Incorrect model->V at 5, 2");
 	mu_assert(fabs(fabs(matrix_get(model->V, model->K-1, 6, 0)) -
-				fabs(-0.0076471781062262)) < eps,
+				fabs(-0.1010202110238350)) < eps,
 			"Incorrect model->V at 6, 0");
 	mu_assert(fabs(fabs(matrix_get(model->V, model->K-1, 6, 1)) -
-				fabs(-0.8781872510019056)) < eps,
+				fabs(-1.7921615999242961)) < eps,
 			"Incorrect model->V at 6, 1");
 	mu_assert(fabs(fabs(matrix_get(model->V, model->K-1, 6, 2)) -
-				fabs(-0.2782284589344380)) < eps,
+				fabs(-0.6850178130530472)) < eps,
 			"Incorrect model->V at 6, 2");
+
 	// end test code //
 
 	gensvm_free_model(model);