Remove kernelparam array in favour of explicit kernel parameters

This simplifies a lot of the code and will make it easier to link
to other languages.

6 files changed, 578 insertions, 616 deletions

diff --git a/tests/aux/test_kernel_dot_sparse.m b/tests/aux/test_kernel_dot_sparse.m
new file mode 100644
index 0000000..86a439e
--- /dev/null
+++ b/tests/aux/test_kernel_dot_sparse.m
@@ -0,0 +1,25 @@
+#function test_kernel_dot_sparse(kerneltype)
+
+  kerneltype = 'rbf'; 
+ 
+  X = [1 2 0 0 0 0;
+       0 3 0 4 0 0;
+       0 0 5 6 7 0;
+       0 0 0 0 0 8];
+  [n, m] = size(X);
+  spZ = sparse([ones(n, 1), X]);
+  
+  gamma = 0.05;
+  degree = 1.7;
+  const = 0.75;
+  
+  K = zeros(n, n);
+  if strcmp(kerneltype, 'rbf')
+    for i=1:n
+      for j=1:n
+        K(i, j) = exp(-gamma * sum((spZ(i, 2:end) - spZ(j, 2:end)).^2));
+      end
+    end
+  end
+
+#end
\ No newline at end of file
diff --git a/tests/src/test_gensvm_copy.c b/tests/src/test_gensvm_copy.c
index 0064eb9..ff5b86d 100644
--- a/tests/src/test_gensvm_copy.c
+++ b/tests/src/test_gensvm_copy.c
@@ -66,10 +66,9 @@ char *test_copy_model_poly_1()
 	from_model->kappa = 1.0;
 	from_model->weight_idx = 2;
 	from_model->kerneltype = K_POLY;
-	from_model->kernelparam = Calloc(double, 3);
-	from_model->kernelparam[0] = 1.0;
-	from_model->kernelparam[1] = 2.0;
-	from_model->kernelparam[2] = 3.0;
+	from_model->gamma = 1.0;
+	from_model->coef = 2.0;
+	from_model->degree = 3.0;
 
 	gensvm_copy_model(from_model, to_model);
 
@@ -79,12 +78,9 @@ char *test_copy_model_poly_1()
 	mu_assert(to_model->kappa == 1.0, "to->kappa incorrect.");
 	mu_assert(to_model->weight_idx == 2, "to->weight_idx incorrect.");
 	mu_assert(to_model->kerneltype == K_POLY, "to->kerneltype incorrect");
-	mu_assert(to_model->kernelparam[0] == 1.0,
-			"to->kernelparam[0] is incorrect.");
-	mu_assert(to_model->kernelparam[1] == 2.0,
-			"to->kernelparam[1] is incorrect.");
-	mu_assert(to_model->kernelparam[2] == 3.0,
-			"to->kernelparam[2] is incorrect.");
+	mu_assert(to_model->gamma == 1.0, "to->gamma is incorrect.");
+	mu_assert(to_model->coef == 2.0, "to->coef is incorrect.");
+	mu_assert(to_model->degree == 3.0, "to->degree is incorrect.");
 
 	gensvm_free_model(from_model);
 	gensvm_free_model(to_model);
@@ -103,11 +99,9 @@ char *test_copy_model_poly_2()
 	from_model->kappa = 1.0;
 	from_model->weight_idx = 2;
 	from_model->kerneltype = K_POLY;
-	from_model->kernelparam = Calloc(double, 3);
-	from_model->kernelparam[0] = 1.0;
-	from_model->kernelparam[1] = 2.0;
-	from_model->kernelparam[2] = 3.0;
-	to_model->kernelparam = Calloc(double, 3);
+	from_model->gamma = 1.0;
+	from_model->coef = 2.0;
+	from_model->degree = 3.0;
 
 	gensvm_copy_model(from_model, to_model);
 
@@ -118,12 +112,9 @@ char *test_copy_model_poly_2()
 	mu_assert(to_model->weight_idx == 2,
 		       	"to_model->weight_idx incorrect.");
 	mu_assert(to_model->kerneltype == K_POLY, "to->kerneltype incorrect");
-	mu_assert(to_model->kernelparam[0] == 1.0,
-			"to->kernelparam[0] is incorrect.");
-	mu_assert(to_model->kernelparam[1] == 2.0,
-			"to->kernelparam[1] is incorrect.");
-	mu_assert(to_model->kernelparam[2] == 3.0,
-			"to->kernelparam[2] is incorrect.");
+	mu_assert(to_model->gamma == 1.0, "to->gamma is incorrect.");
+	mu_assert(to_model->coef == 2.0, "to->coef is incorrect.");
+	mu_assert(to_model->degree == 3.0, "to->degree is incorrect.");
 
 	gensvm_free_model(from_model);
 	gensvm_free_model(to_model);
@@ -142,8 +133,7 @@ char *test_copy_model_rbf_1()
 	from_model->kappa = 1.0;
 	from_model->weight_idx = 2;
 	from_model->kerneltype = K_RBF;
-	from_model->kernelparam = Calloc(double, 1);
-	from_model->kernelparam[0] = 5.0;
+	from_model->gamma = 5.0;
 
 	gensvm_copy_model(from_model, to_model);
 
@@ -154,8 +144,7 @@ char *test_copy_model_rbf_1()
 	mu_assert(to_model->weight_idx == 2,
 		       	"to_model->weight_idx incorrect.");
 	mu_assert(to_model->kerneltype == K_RBF, "to->kerneltype incorrect");
-	mu_assert(to_model->kernelparam[0] == 5.0,
-			"to->kernelparam[0] is incorrect.");
+	mu_assert(to_model->gamma == 5.0, "to->gamma is incorrect.");
 
 	gensvm_free_model(from_model);
 	gensvm_free_model(to_model);
@@ -174,9 +163,7 @@ char *test_copy_model_rbf_2()
 	from_model->kappa = 1.0;
 	from_model->weight_idx = 2;
 	from_model->kerneltype = K_RBF;
-	from_model->kernelparam = Calloc(double, 1);
-	from_model->kernelparam[0] = 5.0;
-	to_model->kernelparam = Calloc(double, 1);
+	from_model->gamma = 5.0;
 
 	gensvm_copy_model(from_model, to_model);
 
@@ -187,8 +174,7 @@ char *test_copy_model_rbf_2()
 	mu_assert(to_model->weight_idx == 2,
 		       	"to_model->weight_idx incorrect.");
 	mu_assert(to_model->kerneltype == K_RBF, "to->kerneltype incorrect");
-	mu_assert(to_model->kernelparam[0] == 5.0,
-			"to->kernelparam[0] is incorrect.");
+	mu_assert(to_model->gamma == 5.0, "to->gamma is incorrect.");
 
 	gensvm_free_model(from_model);
 	gensvm_free_model(to_model);
@@ -207,9 +193,8 @@ char *test_copy_model_sigmoid_1()
 	from_model->kappa = 1.0;
 	from_model->weight_idx = 2;
 	from_model->kerneltype = K_SIGMOID;
-	from_model->kernelparam = Calloc(double, 2);
-	from_model->kernelparam[0] = 5.0;
-	from_model->kernelparam[1] = 10.0;
+	from_model->gamma = 5.0;
+	from_model->coef = 10.0;
 
 	gensvm_copy_model(from_model, to_model);
 
@@ -221,10 +206,8 @@ char *test_copy_model_sigmoid_1()
 		       	"to_model->weight_idx incorrect.");
 	mu_assert(to_model->kerneltype == K_SIGMOID,
 		       	"to->kerneltype incorrect");
-	mu_assert(to_model->kernelparam[0] == 5.0,
-			"to->kernelparam[0] is incorrect.");
-	mu_assert(to_model->kernelparam[1] == 10.0,
-			"to->kernelparam[1] is incorrect.");
+	mu_assert(to_model->gamma == 5.0, "to->gamma is incorrect.");
+	mu_assert(to_model->coef == 10.0, "to->coef is incorrect.");
 
 	gensvm_free_model(from_model);
 	gensvm_free_model(to_model);
@@ -243,10 +226,8 @@ char *test_copy_model_sigmoid_2()
 	from_model->kappa = 1.0;
 	from_model->weight_idx = 2;
 	from_model->kerneltype = K_SIGMOID;
-	from_model->kernelparam = Calloc(double, 2);
-	from_model->kernelparam[0] = 5.0;
-	from_model->kernelparam[1] = 10.0;
-	to_model->kernelparam = Calloc(double, 2);
+	from_model->gamma = 5.0;
+	from_model->coef = 10.0;
 
 	gensvm_copy_model(from_model, to_model);
 
@@ -258,10 +239,8 @@ char *test_copy_model_sigmoid_2()
 		       	"to_model->weight_idx incorrect.");
 	mu_assert(to_model->kerneltype == K_SIGMOID,
 		       	"to->kerneltype incorrect");
-	mu_assert(to_model->kernelparam[0] == 5.0,
-			"to->kernelparam[0] is incorrect.");
-	mu_assert(to_model->kernelparam[1] == 10.0,
-			"to->kernelparam[1] is incorrect.");
+	mu_assert(to_model->gamma == 5.0, "to->gamma is incorrect.");
+	mu_assert(to_model->coef == 10.0, "to->coef is incorrect.");
 
 	gensvm_free_model(from_model);
 	gensvm_free_model(to_model);
diff --git a/tests/src/test_gensvm_gridsearch.c b/tests/src/test_gensvm_gridsearch.c
index cd3d557..93c1212 100644
--- a/tests/src/test_gensvm_gridsearch.c
+++ b/tests/src/test_gensvm_gridsearch.c
@@ -408,440 +408,440 @@ char *test_fill_queue_kernel()
 	mu_assert(q->tasks[71]->lambda == 5.000000,
 			"Incorrect lambda at task 71");
 
-	mu_assert(q->tasks[0]->kernelparam[0] == 0.500000,
-			"Incorrect kernelparam 0 at task 0");
-	mu_assert(q->tasks[1]->kernelparam[0] == 0.500000,
-			"Incorrect kernelparam 0 at task 1");
-	mu_assert(q->tasks[2]->kernelparam[0] == 0.500000,
-			"Incorrect kernelparam 0 at task 2");
-	mu_assert(q->tasks[3]->kernelparam[0] == 0.500000,
-			"Incorrect kernelparam 0 at task 3");
-	mu_assert(q->tasks[4]->kernelparam[0] == 0.500000,
-			"Incorrect kernelparam 0 at task 4");
-	mu_assert(q->tasks[5]->kernelparam[0] == 0.500000,
-			"Incorrect kernelparam 0 at task 5");
-	mu_assert(q->tasks[6]->kernelparam[0] == 1.500000,
-			"Incorrect kernelparam 0 at task 6");
-	mu_assert(q->tasks[7]->kernelparam[0] == 1.500000,
-			"Incorrect kernelparam 0 at task 7");
-	mu_assert(q->tasks[8]->kernelparam[0] == 1.500000,
-			"Incorrect kernelparam 0 at task 8");
-	mu_assert(q->tasks[9]->kernelparam[0] == 1.500000,
-			"Incorrect kernelparam 0 at task 9");
-	mu_assert(q->tasks[10]->kernelparam[0] == 1.500000,
-			"Incorrect kernelparam 0 at task 10");
-	mu_assert(q->tasks[11]->kernelparam[0] == 1.500000,
-			"Incorrect kernelparam 0 at task 11");
-	mu_assert(q->tasks[12]->kernelparam[0] == 0.500000,
-			"Incorrect kernelparam 0 at task 12");
-	mu_assert(q->tasks[13]->kernelparam[0] == 0.500000,
-			"Incorrect kernelparam 0 at task 13");
-	mu_assert(q->tasks[14]->kernelparam[0] == 0.500000,
-			"Incorrect kernelparam 0 at task 14");
-	mu_assert(q->tasks[15]->kernelparam[0] == 0.500000,
-			"Incorrect kernelparam 0 at task 15");
-	mu_assert(q->tasks[16]->kernelparam[0] == 0.500000,
-			"Incorrect kernelparam 0 at task 16");
-	mu_assert(q->tasks[17]->kernelparam[0] == 0.500000,
-			"Incorrect kernelparam 0 at task 17");
-	mu_assert(q->tasks[18]->kernelparam[0] == 1.500000,
-			"Incorrect kernelparam 0 at task 18");
-	mu_assert(q->tasks[19]->kernelparam[0] == 1.500000,
-			"Incorrect kernelparam 0 at task 19");
-	mu_assert(q->tasks[20]->kernelparam[0] == 1.500000,
-			"Incorrect kernelparam 0 at task 20");
-	mu_assert(q->tasks[21]->kernelparam[0] == 1.500000,
-			"Incorrect kernelparam 0 at task 21");
-	mu_assert(q->tasks[22]->kernelparam[0] == 1.500000,
-			"Incorrect kernelparam 0 at task 22");
-	mu_assert(q->tasks[23]->kernelparam[0] == 1.500000,
-			"Incorrect kernelparam 0 at task 23");
-	mu_assert(q->tasks[24]->kernelparam[0] == 0.500000,
-			"Incorrect kernelparam 0 at task 24");
-	mu_assert(q->tasks[25]->kernelparam[0] == 0.500000,
-			"Incorrect kernelparam 0 at task 25");
-	mu_assert(q->tasks[26]->kernelparam[0] == 0.500000,
-			"Incorrect kernelparam 0 at task 26");
-	mu_assert(q->tasks[27]->kernelparam[0] == 0.500000,
-			"Incorrect kernelparam 0 at task 27");
-	mu_assert(q->tasks[28]->kernelparam[0] == 0.500000,
-			"Incorrect kernelparam 0 at task 28");
-	mu_assert(q->tasks[29]->kernelparam[0] == 0.500000,
-			"Incorrect kernelparam 0 at task 29");
-	mu_assert(q->tasks[30]->kernelparam[0] == 1.500000,
-			"Incorrect kernelparam 0 at task 30");
-	mu_assert(q->tasks[31]->kernelparam[0] == 1.500000,
-			"Incorrect kernelparam 0 at task 31");
-	mu_assert(q->tasks[32]->kernelparam[0] == 1.500000,
-			"Incorrect kernelparam 0 at task 32");
-	mu_assert(q->tasks[33]->kernelparam[0] == 1.500000,
-			"Incorrect kernelparam 0 at task 33");
-	mu_assert(q->tasks[34]->kernelparam[0] == 1.500000,
-			"Incorrect kernelparam 0 at task 34");
-	mu_assert(q->tasks[35]->kernelparam[0] == 1.500000,
-			"Incorrect kernelparam 0 at task 35");
-	mu_assert(q->tasks[36]->kernelparam[0] == 0.500000,
-			"Incorrect kernelparam 0 at task 36");
-	mu_assert(q->tasks[37]->kernelparam[0] == 0.500000,
-			"Incorrect kernelparam 0 at task 37");
-	mu_assert(q->tasks[38]->kernelparam[0] == 0.500000,
-			"Incorrect kernelparam 0 at task 38");
-	mu_assert(q->tasks[39]->kernelparam[0] == 0.500000,
-			"Incorrect kernelparam 0 at task 39");
-	mu_assert(q->tasks[40]->kernelparam[0] == 0.500000,
-			"Incorrect kernelparam 0 at task 40");
-	mu_assert(q->tasks[41]->kernelparam[0] == 0.500000,
-			"Incorrect kernelparam 0 at task 41");
-	mu_assert(q->tasks[42]->kernelparam[0] == 1.500000,
-			"Incorrect kernelparam 0 at task 42");
-	mu_assert(q->tasks[43]->kernelparam[0] == 1.500000,
-			"Incorrect kernelparam 0 at task 43");
-	mu_assert(q->tasks[44]->kernelparam[0] == 1.500000,
-			"Incorrect kernelparam 0 at task 44");
-	mu_assert(q->tasks[45]->kernelparam[0] == 1.500000,
-			"Incorrect kernelparam 0 at task 45");
-	mu_assert(q->tasks[46]->kernelparam[0] == 1.500000,
-			"Incorrect kernelparam 0 at task 46");
-	mu_assert(q->tasks[47]->kernelparam[0] == 1.500000,
-			"Incorrect kernelparam 0 at task 47");
-	mu_assert(q->tasks[48]->kernelparam[0] == 0.500000,
-			"Incorrect kernelparam 0 at task 48");
-	mu_assert(q->tasks[49]->kernelparam[0] == 0.500000,
-			"Incorrect kernelparam 0 at task 49");
-	mu_assert(q->tasks[50]->kernelparam[0] == 0.500000,
-			"Incorrect kernelparam 0 at task 50");
-	mu_assert(q->tasks[51]->kernelparam[0] == 0.500000,
-			"Incorrect kernelparam 0 at task 51");
-	mu_assert(q->tasks[52]->kernelparam[0] == 0.500000,
-			"Incorrect kernelparam 0 at task 52");
-	mu_assert(q->tasks[53]->kernelparam[0] == 0.500000,
-			"Incorrect kernelparam 0 at task 53");
-	mu_assert(q->tasks[54]->kernelparam[0] == 1.500000,
-			"Incorrect kernelparam 0 at task 54");
-	mu_assert(q->tasks[55]->kernelparam[0] == 1.500000,
-			"Incorrect kernelparam 0 at task 55");
-	mu_assert(q->tasks[56]->kernelparam[0] == 1.500000,
-			"Incorrect kernelparam 0 at task 56");
-	mu_assert(q->tasks[57]->kernelparam[0] == 1.500000,
-			"Incorrect kernelparam 0 at task 57");
-	mu_assert(q->tasks[58]->kernelparam[0] == 1.500000,
-			"Incorrect kernelparam 0 at task 58");
-	mu_assert(q->tasks[59]->kernelparam[0] == 1.500000,
-			"Incorrect kernelparam 0 at task 59");
-	mu_assert(q->tasks[60]->kernelparam[0] == 0.500000,
-			"Incorrect kernelparam 0 at task 60");
-	mu_assert(q->tasks[61]->kernelparam[0] == 0.500000,
-			"Incorrect kernelparam 0 at task 61");
-	mu_assert(q->tasks[62]->kernelparam[0] == 0.500000,
-			"Incorrect kernelparam 0 at task 62");
-	mu_assert(q->tasks[63]->kernelparam[0] == 0.500000,
-			"Incorrect kernelparam 0 at task 63");
-	mu_assert(q->tasks[64]->kernelparam[0] == 0.500000,
-			"Incorrect kernelparam 0 at task 64");
-	mu_assert(q->tasks[65]->kernelparam[0] == 0.500000,
-			"Incorrect kernelparam 0 at task 65");
-	mu_assert(q->tasks[66]->kernelparam[0] == 1.500000,
-			"Incorrect kernelparam 0 at task 66");
-	mu_assert(q->tasks[67]->kernelparam[0] == 1.500000,
-			"Incorrect kernelparam 0 at task 67");
-	mu_assert(q->tasks[68]->kernelparam[0] == 1.500000,
-			"Incorrect kernelparam 0 at task 68");
-	mu_assert(q->tasks[69]->kernelparam[0] == 1.500000,
-			"Incorrect kernelparam 0 at task 69");
-	mu_assert(q->tasks[70]->kernelparam[0] == 1.500000,
-			"Incorrect kernelparam 0 at task 70");
-	mu_assert(q->tasks[71]->kernelparam[0] == 1.500000,
-			"Incorrect kernelparam 0 at task 71");
-
-	mu_assert(q->tasks[0]->kernelparam[1] == 7.000000,
-			"Incorrect kernelparam 1 at task 0");
-	mu_assert(q->tasks[1]->kernelparam[1] == 7.000000,
-			"Incorrect kernelparam 1 at task 1");
-	mu_assert(q->tasks[2]->kernelparam[1] == 7.000000,
-			"Incorrect kernelparam 1 at task 2");
-	mu_assert(q->tasks[3]->kernelparam[1] == 7.000000,
-			"Incorrect kernelparam 1 at task 3");
-	mu_assert(q->tasks[4]->kernelparam[1] == 7.000000,
-			"Incorrect kernelparam 1 at task 4");
-	mu_assert(q->tasks[5]->kernelparam[1] == 7.000000,
-			"Incorrect kernelparam 1 at task 5");
-	mu_assert(q->tasks[6]->kernelparam[1] == 7.000000,
-			"Incorrect kernelparam 1 at task 6");
-	mu_assert(q->tasks[7]->kernelparam[1] == 7.000000,
-			"Incorrect kernelparam 1 at task 7");
-	mu_assert(q->tasks[8]->kernelparam[1] == 7.000000,
-			"Incorrect kernelparam 1 at task 8");
-	mu_assert(q->tasks[9]->kernelparam[1] == 7.000000,
-			"Incorrect kernelparam 1 at task 9");
-	mu_assert(q->tasks[10]->kernelparam[1] == 7.000000,
-			"Incorrect kernelparam 1 at task 10");
-	mu_assert(q->tasks[11]->kernelparam[1] == 7.000000,
-			"Incorrect kernelparam 1 at task 11");
-	mu_assert(q->tasks[12]->kernelparam[1] == 11.000000,
-			"Incorrect kernelparam 1 at task 12");
-	mu_assert(q->tasks[13]->kernelparam[1] == 11.000000,
-			"Incorrect kernelparam 1 at task 13");
-	mu_assert(q->tasks[14]->kernelparam[1] == 11.000000,
-			"Incorrect kernelparam 1 at task 14");
-	mu_assert(q->tasks[15]->kernelparam[1] == 11.000000,
-			"Incorrect kernelparam 1 at task 15");
-	mu_assert(q->tasks[16]->kernelparam[1] == 11.000000,
-			"Incorrect kernelparam 1 at task 16");
-	mu_assert(q->tasks[17]->kernelparam[1] == 11.000000,
-			"Incorrect kernelparam 1 at task 17");
-	mu_assert(q->tasks[18]->kernelparam[1] == 11.000000,
-			"Incorrect kernelparam 1 at task 18");
-	mu_assert(q->tasks[19]->kernelparam[1] == 11.000000,
-			"Incorrect kernelparam 1 at task 19");
-	mu_assert(q->tasks[20]->kernelparam[1] == 11.000000,
-			"Incorrect kernelparam 1 at task 20");
-	mu_assert(q->tasks[21]->kernelparam[1] == 11.000000,
-			"Incorrect kernelparam 1 at task 21");
-	mu_assert(q->tasks[22]->kernelparam[1] == 11.000000,
-			"Incorrect kernelparam 1 at task 22");
-	mu_assert(q->tasks[23]->kernelparam[1] == 11.000000,
-			"Incorrect kernelparam 1 at task 23");
-	mu_assert(q->tasks[24]->kernelparam[1] == 13.000000,
-			"Incorrect kernelparam 1 at task 24");
-	mu_assert(q->tasks[25]->kernelparam[1] == 13.000000,
-			"Incorrect kernelparam 1 at task 25");
-	mu_assert(q->tasks[26]->kernelparam[1] == 13.000000,
-			"Incorrect kernelparam 1 at task 26");
-	mu_assert(q->tasks[27]->kernelparam[1] == 13.000000,
-			"Incorrect kernelparam 1 at task 27");
-	mu_assert(q->tasks[28]->kernelparam[1] == 13.000000,
-			"Incorrect kernelparam 1 at task 28");
-	mu_assert(q->tasks[29]->kernelparam[1] == 13.000000,
-			"Incorrect kernelparam 1 at task 29");
-	mu_assert(q->tasks[30]->kernelparam[1] == 13.000000,
-			"Incorrect kernelparam 1 at task 30");
-	mu_assert(q->tasks[31]->kernelparam[1] == 13.000000,
-			"Incorrect kernelparam 1 at task 31");
-	mu_assert(q->tasks[32]->kernelparam[1] == 13.000000,
-			"Incorrect kernelparam 1 at task 32");
-	mu_assert(q->tasks[33]->kernelparam[1] == 13.000000,
-			"Incorrect kernelparam 1 at task 33");
-	mu_assert(q->tasks[34]->kernelparam[1] == 13.000000,
-			"Incorrect kernelparam 1 at task 34");
-	mu_assert(q->tasks[35]->kernelparam[1] == 13.000000,
-			"Incorrect kernelparam 1 at task 35");
-	mu_assert(q->tasks[36]->kernelparam[1] == 7.000000,
-			"Incorrect kernelparam 1 at task 36");
-	mu_assert(q->tasks[37]->kernelparam[1] == 7.000000,
-			"Incorrect kernelparam 1 at task 37");
-	mu_assert(q->tasks[38]->kernelparam[1] == 7.000000,
-			"Incorrect kernelparam 1 at task 38");
-	mu_assert(q->tasks[39]->kernelparam[1] == 7.000000,
-			"Incorrect kernelparam 1 at task 39");
-	mu_assert(q->tasks[40]->kernelparam[1] == 7.000000,
-			"Incorrect kernelparam 1 at task 40");
-	mu_assert(q->tasks[41]->kernelparam[1] == 7.000000,
-			"Incorrect kernelparam 1 at task 41");
-	mu_assert(q->tasks[42]->kernelparam[1] == 7.000000,
-			"Incorrect kernelparam 1 at task 42");
-	mu_assert(q->tasks[43]->kernelparam[1] == 7.000000,
-			"Incorrect kernelparam 1 at task 43");
-	mu_assert(q->tasks[44]->kernelparam[1] == 7.000000,
-			"Incorrect kernelparam 1 at task 44");
-	mu_assert(q->tasks[45]->kernelparam[1] == 7.000000,
-			"Incorrect kernelparam 1 at task 45");
-	mu_assert(q->tasks[46]->kernelparam[1] == 7.000000,
-			"Incorrect kernelparam 1 at task 46");
-	mu_assert(q->tasks[47]->kernelparam[1] == 7.000000,
-			"Incorrect kernelparam 1 at task 47");
-	mu_assert(q->tasks[48]->kernelparam[1] == 11.000000,
-			"Incorrect kernelparam 1 at task 48");
-	mu_assert(q->tasks[49]->kernelparam[1] == 11.000000,
-			"Incorrect kernelparam 1 at task 49");
-	mu_assert(q->tasks[50]->kernelparam[1] == 11.000000,
-			"Incorrect kernelparam 1 at task 50");
-	mu_assert(q->tasks[51]->kernelparam[1] == 11.000000,
-			"Incorrect kernelparam 1 at task 51");
-	mu_assert(q->tasks[52]->kernelparam[1] == 11.000000,
-			"Incorrect kernelparam 1 at task 52");
-	mu_assert(q->tasks[53]->kernelparam[1] == 11.000000,
-			"Incorrect kernelparam 1 at task 53");
-	mu_assert(q->tasks[54]->kernelparam[1] == 11.000000,
-			"Incorrect kernelparam 1 at task 54");
-	mu_assert(q->tasks[55]->kernelparam[1] == 11.000000,
-			"Incorrect kernelparam 1 at task 55");
-	mu_assert(q->tasks[56]->kernelparam[1] == 11.000000,
-			"Incorrect kernelparam 1 at task 56");
-	mu_assert(q->tasks[57]->kernelparam[1] == 11.000000,
-			"Incorrect kernelparam 1 at task 57");
-	mu_assert(q->tasks[58]->kernelparam[1] == 11.000000,
-			"Incorrect kernelparam 1 at task 58");
-	mu_assert(q->tasks[59]->kernelparam[1] == 11.000000,
-			"Incorrect kernelparam 1 at task 59");
-	mu_assert(q->tasks[60]->kernelparam[1] == 13.000000,
-			"Incorrect kernelparam 1 at task 60");
-	mu_assert(q->tasks[61]->kernelparam[1] == 13.000000,
-			"Incorrect kernelparam 1 at task 61");
-	mu_assert(q->tasks[62]->kernelparam[1] == 13.000000,
-			"Incorrect kernelparam 1 at task 62");
-	mu_assert(q->tasks[63]->kernelparam[1] == 13.000000,
-			"Incorrect kernelparam 1 at task 63");
-	mu_assert(q->tasks[64]->kernelparam[1] == 13.000000,
-			"Incorrect kernelparam 1 at task 64");
-	mu_assert(q->tasks[65]->kernelparam[1] == 13.000000,
-			"Incorrect kernelparam 1 at task 65");
-	mu_assert(q->tasks[66]->kernelparam[1] == 13.000000,
-			"Incorrect kernelparam 1 at task 66");
-	mu_assert(q->tasks[67]->kernelparam[1] == 13.000000,
-			"Incorrect kernelparam 1 at task 67");
-	mu_assert(q->tasks[68]->kernelparam[1] == 13.000000,
-			"Incorrect kernelparam 1 at task 68");
-	mu_assert(q->tasks[69]->kernelparam[1] == 13.000000,
-			"Incorrect kernelparam 1 at task 69");
-	mu_assert(q->tasks[70]->kernelparam[1] == 13.000000,
-			"Incorrect kernelparam 1 at task 70");
-	mu_assert(q->tasks[71]->kernelparam[1] == 13.000000,
-			"Incorrect kernelparam 1 at task 71");
-
-	mu_assert(q->tasks[0]->kernelparam[2] == 3.000000,
-			"Incorrect kernelparam 2 at task 0");
-	mu_assert(q->tasks[1]->kernelparam[2] == 3.000000,
-			"Incorrect kernelparam 2 at task 1");
-	mu_assert(q->tasks[2]->kernelparam[2] == 3.000000,
-			"Incorrect kernelparam 2 at task 2");
-	mu_assert(q->tasks[3]->kernelparam[2] == 3.000000,
-			"Incorrect kernelparam 2 at task 3");
-	mu_assert(q->tasks[4]->kernelparam[2] == 3.000000,
-			"Incorrect kernelparam 2 at task 4");
-	mu_assert(q->tasks[5]->kernelparam[2] == 3.000000,
-			"Incorrect kernelparam 2 at task 5");
-	mu_assert(q->tasks[6]->kernelparam[2] == 3.000000,
-			"Incorrect kernelparam 2 at task 6");
-	mu_assert(q->tasks[7]->kernelparam[2] == 3.000000,
-			"Incorrect kernelparam 2 at task 7");
-	mu_assert(q->tasks[8]->kernelparam[2] == 3.000000,
-			"Incorrect kernelparam 2 at task 8");
-	mu_assert(q->tasks[9]->kernelparam[2] == 3.000000,
-			"Incorrect kernelparam 2 at task 9");
-	mu_assert(q->tasks[10]->kernelparam[2] == 3.000000,
-			"Incorrect kernelparam 2 at task 10");
-	mu_assert(q->tasks[11]->kernelparam[2] == 3.000000,
-			"Incorrect kernelparam 2 at task 11");
-	mu_assert(q->tasks[12]->kernelparam[2] == 3.000000,
-			"Incorrect kernelparam 2 at task 12");
-	mu_assert(q->tasks[13]->kernelparam[2] == 3.000000,
-			"Incorrect kernelparam 2 at task 13");
-	mu_assert(q->tasks[14]->kernelparam[2] == 3.000000,
-			"Incorrect kernelparam 2 at task 14");
-	mu_assert(q->tasks[15]->kernelparam[2] == 3.000000,
-			"Incorrect kernelparam 2 at task 15");
-	mu_assert(q->tasks[16]->kernelparam[2] == 3.000000,
-			"Incorrect kernelparam 2 at task 16");
-	mu_assert(q->tasks[17]->kernelparam[2] == 3.000000,
-			"Incorrect kernelparam 2 at task 17");
-	mu_assert(q->tasks[18]->kernelparam[2] == 3.000000,
-			"Incorrect kernelparam 2 at task 18");
-	mu_assert(q->tasks[19]->kernelparam[2] == 3.000000,
-			"Incorrect kernelparam 2 at task 19");
-	mu_assert(q->tasks[20]->kernelparam[2] == 3.000000,
-			"Incorrect kernelparam 2 at task 20");
-	mu_assert(q->tasks[21]->kernelparam[2] == 3.000000,
-			"Incorrect kernelparam 2 at task 21");
-	mu_assert(q->tasks[22]->kernelparam[2] == 3.000000,
-			"Incorrect kernelparam 2 at task 22");
-	mu_assert(q->tasks[23]->kernelparam[2] == 3.000000,
-			"Incorrect kernelparam 2 at task 23");
-	mu_assert(q->tasks[24]->kernelparam[2] == 3.000000,
-			"Incorrect kernelparam 2 at task 24");
-	mu_assert(q->tasks[25]->kernelparam[2] == 3.000000,
-			"Incorrect kernelparam 2 at task 25");
-	mu_assert(q->tasks[26]->kernelparam[2] == 3.000000,
-			"Incorrect kernelparam 2 at task 26");
-	mu_assert(q->tasks[27]->kernelparam[2] == 3.000000,
-			"Incorrect kernelparam 2 at task 27");
-	mu_assert(q->tasks[28]->kernelparam[2] == 3.000000,
-			"Incorrect kernelparam 2 at task 28");
-	mu_assert(q->tasks[29]->kernelparam[2] == 3.000000,
-			"Incorrect kernelparam 2 at task 29");
-	mu_assert(q->tasks[30]->kernelparam[2] == 3.000000,
-			"Incorrect kernelparam 2 at task 30");
-	mu_assert(q->tasks[31]->kernelparam[2] == 3.000000,
-			"Incorrect kernelparam 2 at task 31");
-	mu_assert(q->tasks[32]->kernelparam[2] == 3.000000,
-			"Incorrect kernelparam 2 at task 32");
-	mu_assert(q->tasks[33]->kernelparam[2] == 3.000000,
-			"Incorrect kernelparam 2 at task 33");
-	mu_assert(q->tasks[34]->kernelparam[2] == 3.000000,
-			"Incorrect kernelparam 2 at task 34");
-	mu_assert(q->tasks[35]->kernelparam[2] == 3.000000,
-			"Incorrect kernelparam 2 at task 35");
-	mu_assert(q->tasks[36]->kernelparam[2] == 5.000000,
-			"Incorrect kernelparam 2 at task 36");
-	mu_assert(q->tasks[37]->kernelparam[2] == 5.000000,
-			"Incorrect kernelparam 2 at task 37");
-	mu_assert(q->tasks[38]->kernelparam[2] == 5.000000,
-			"Incorrect kernelparam 2 at task 38");
-	mu_assert(q->tasks[39]->kernelparam[2] == 5.000000,
-			"Incorrect kernelparam 2 at task 39");
-	mu_assert(q->tasks[40]->kernelparam[2] == 5.000000,
-			"Incorrect kernelparam 2 at task 40");
-	mu_assert(q->tasks[41]->kernelparam[2] == 5.000000,
-			"Incorrect kernelparam 2 at task 41");
-	mu_assert(q->tasks[42]->kernelparam[2] == 5.000000,
-			"Incorrect kernelparam 2 at task 42");
-	mu_assert(q->tasks[43]->kernelparam[2] == 5.000000,
-			"Incorrect kernelparam 2 at task 43");
-	mu_assert(q->tasks[44]->kernelparam[2] == 5.000000,
-			"Incorrect kernelparam 2 at task 44");
-	mu_assert(q->tasks[45]->kernelparam[2] == 5.000000,
-			"Incorrect kernelparam 2 at task 45");
-	mu_assert(q->tasks[46]->kernelparam[2] == 5.000000,
-			"Incorrect kernelparam 2 at task 46");
-	mu_assert(q->tasks[47]->kernelparam[2] == 5.000000,
-			"Incorrect kernelparam 2 at task 47");
-	mu_assert(q->tasks[48]->kernelparam[2] == 5.000000,
-			"Incorrect kernelparam 2 at task 48");
-	mu_assert(q->tasks[49]->kernelparam[2] == 5.000000,
-			"Incorrect kernelparam 2 at task 49");
-	mu_assert(q->tasks[50]->kernelparam[2] == 5.000000,
-			"Incorrect kernelparam 2 at task 50");
-	mu_assert(q->tasks[51]->kernelparam[2] == 5.000000,
-			"Incorrect kernelparam 2 at task 51");
-	mu_assert(q->tasks[52]->kernelparam[2] == 5.000000,
-			"Incorrect kernelparam 2 at task 52");
-	mu_assert(q->tasks[53]->kernelparam[2] == 5.000000,
-			"Incorrect kernelparam 2 at task 53");
-	mu_assert(q->tasks[54]->kernelparam[2] == 5.000000,
-			"Incorrect kernelparam 2 at task 54");
-	mu_assert(q->tasks[55]->kernelparam[2] == 5.000000,
-			"Incorrect kernelparam 2 at task 55");
-	mu_assert(q->tasks[56]->kernelparam[2] == 5.000000,
-			"Incorrect kernelparam 2 at task 56");
-	mu_assert(q->tasks[57]->kernelparam[2] == 5.000000,
-			"Incorrect kernelparam 2 at task 57");
-	mu_assert(q->tasks[58]->kernelparam[2] == 5.000000,
-			"Incorrect kernelparam 2 at task 58");
-	mu_assert(q->tasks[59]->kernelparam[2] == 5.000000,
-			"Incorrect kernelparam 2 at task 59");
-	mu_assert(q->tasks[60]->kernelparam[2] == 5.000000,
-			"Incorrect kernelparam 2 at task 60");
-	mu_assert(q->tasks[61]->kernelparam[2] == 5.000000,
-			"Incorrect kernelparam 2 at task 61");
-	mu_assert(q->tasks[62]->kernelparam[2] == 5.000000,
-			"Incorrect kernelparam 2 at task 62");
-	mu_assert(q->tasks[63]->kernelparam[2] == 5.000000,
-			"Incorrect kernelparam 2 at task 63");
-	mu_assert(q->tasks[64]->kernelparam[2] == 5.000000,
-			"Incorrect kernelparam 2 at task 64");
-	mu_assert(q->tasks[65]->kernelparam[2] == 5.000000,
-			"Incorrect kernelparam 2 at task 65");
-	mu_assert(q->tasks[66]->kernelparam[2] == 5.000000,
-			"Incorrect kernelparam 2 at task 66");
-	mu_assert(q->tasks[67]->kernelparam[2] == 5.000000,
-			"Incorrect kernelparam 2 at task 67");
-	mu_assert(q->tasks[68]->kernelparam[2] == 5.000000,
-			"Incorrect kernelparam 2 at task 68");
-	mu_assert(q->tasks[69]->kernelparam[2] == 5.000000,
-			"Incorrect kernelparam 2 at task 69");
-	mu_assert(q->tasks[70]->kernelparam[2] == 5.000000,
-			"Incorrect kernelparam 2 at task 70");
-	mu_assert(q->tasks[71]->kernelparam[2] == 5.000000,
-			"Incorrect kernelparam 2 at task 71");
+	mu_assert(q->tasks[0]->gamma == 0.500000,
+			"Incorrect gamma at task 0");
+	mu_assert(q->tasks[1]->gamma == 0.500000,
+			"Incorrect gamma at task 1");
+	mu_assert(q->tasks[2]->gamma == 0.500000,
+			"Incorrect gamma at task 2");
+	mu_assert(q->tasks[3]->gamma == 0.500000,
+			"Incorrect gamma at task 3");
+	mu_assert(q->tasks[4]->gamma == 0.500000,
+			"Incorrect gamma at task 4");
+	mu_assert(q->tasks[5]->gamma == 0.500000,
+			"Incorrect gamma at task 5");
+	mu_assert(q->tasks[6]->gamma == 1.500000,
+			"Incorrect gamma at task 6");
+	mu_assert(q->tasks[7]->gamma == 1.500000,
+			"Incorrect gamma at task 7");
+	mu_assert(q->tasks[8]->gamma == 1.500000,
+			"Incorrect gamma at task 8");
+	mu_assert(q->tasks[9]->gamma == 1.500000,
+			"Incorrect gamma at task 9");
+	mu_assert(q->tasks[10]->gamma == 1.500000,
+			"Incorrect gamma at task 10");
+	mu_assert(q->tasks[11]->gamma == 1.500000,
+			"Incorrect gamma at task 11");
+	mu_assert(q->tasks[12]->gamma == 0.500000,
+			"Incorrect gamma at task 12");
+	mu_assert(q->tasks[13]->gamma == 0.500000,
+			"Incorrect gamma at task 13");
+	mu_assert(q->tasks[14]->gamma == 0.500000,
+			"Incorrect gamma at task 14");
+	mu_assert(q->tasks[15]->gamma == 0.500000,
+			"Incorrect gamma at task 15");
+	mu_assert(q->tasks[16]->gamma == 0.500000,
+			"Incorrect gamma at task 16");
+	mu_assert(q->tasks[17]->gamma == 0.500000,
+			"Incorrect gamma at task 17");
+	mu_assert(q->tasks[18]->gamma == 1.500000,
+			"Incorrect gamma at task 18");
+	mu_assert(q->tasks[19]->gamma == 1.500000,
+			"Incorrect gamma at task 19");
+	mu_assert(q->tasks[20]->gamma == 1.500000,
+			"Incorrect gamma at task 20");
+	mu_assert(q->tasks[21]->gamma == 1.500000,
+			"Incorrect gamma at task 21");
+	mu_assert(q->tasks[22]->gamma == 1.500000,
+			"Incorrect gamma at task 22");
+	mu_assert(q->tasks[23]->gamma == 1.500000,
+			"Incorrect gamma at task 23");
+	mu_assert(q->tasks[24]->gamma == 0.500000,
+			"Incorrect gamma at task 24");
+	mu_assert(q->tasks[25]->gamma == 0.500000,
+			"Incorrect gamma at task 25");
+	mu_assert(q->tasks[26]->gamma == 0.500000,
+			"Incorrect gamma at task 26");
+	mu_assert(q->tasks[27]->gamma == 0.500000,
+			"Incorrect gamma at task 27");
+	mu_assert(q->tasks[28]->gamma == 0.500000,
+			"Incorrect gamma at task 28");
+	mu_assert(q->tasks[29]->gamma == 0.500000,
+			"Incorrect gamma at task 29");
+	mu_assert(q->tasks[30]->gamma == 1.500000,
+			"Incorrect gamma at task 30");
+	mu_assert(q->tasks[31]->gamma == 1.500000,
+			"Incorrect gamma at task 31");
+	mu_assert(q->tasks[32]->gamma == 1.500000,
+			"Incorrect gamma at task 32");
+	mu_assert(q->tasks[33]->gamma == 1.500000,
+			"Incorrect gamma at task 33");
+	mu_assert(q->tasks[34]->gamma == 1.500000,
+			"Incorrect gamma at task 34");
+	mu_assert(q->tasks[35]->gamma == 1.500000,
+			"Incorrect gamma at task 35");
+	mu_assert(q->tasks[36]->gamma == 0.500000,
+			"Incorrect gamma at task 36");
+	mu_assert(q->tasks[37]->gamma == 0.500000,
+			"Incorrect gamma at task 37");
+	mu_assert(q->tasks[38]->gamma == 0.500000,
+			"Incorrect gamma at task 38");
+	mu_assert(q->tasks[39]->gamma == 0.500000,
+			"Incorrect gamma at task 39");
+	mu_assert(q->tasks[40]->gamma == 0.500000,
+			"Incorrect gamma at task 40");
+	mu_assert(q->tasks[41]->gamma == 0.500000,
+			"Incorrect gamma at task 41");
+	mu_assert(q->tasks[42]->gamma == 1.500000,
+			"Incorrect gamma at task 42");
+	mu_assert(q->tasks[43]->gamma == 1.500000,
+			"Incorrect gamma at task 43");
+	mu_assert(q->tasks[44]->gamma == 1.500000,
+			"Incorrect gamma at task 44");
+	mu_assert(q->tasks[45]->gamma == 1.500000,
+			"Incorrect gamma at task 45");
+	mu_assert(q->tasks[46]->gamma == 1.500000,
+			"Incorrect gamma at task 46");
+	mu_assert(q->tasks[47]->gamma == 1.500000,
+			"Incorrect gamma at task 47");
+	mu_assert(q->tasks[48]->gamma == 0.500000,
+			"Incorrect gamma at task 48");
+	mu_assert(q->tasks[49]->gamma == 0.500000,
+			"Incorrect gamma at task 49");
+	mu_assert(q->tasks[50]->gamma == 0.500000,
+			"Incorrect gamma at task 50");
+	mu_assert(q->tasks[51]->gamma == 0.500000,
+			"Incorrect gamma at task 51");
+	mu_assert(q->tasks[52]->gamma == 0.500000,
+			"Incorrect gamma at task 52");
+	mu_assert(q->tasks[53]->gamma == 0.500000,
+			"Incorrect gamma at task 53");
+	mu_assert(q->tasks[54]->gamma == 1.500000,
+			"Incorrect gamma at task 54");
+	mu_assert(q->tasks[55]->gamma == 1.500000,
+			"Incorrect gamma at task 55");
+	mu_assert(q->tasks[56]->gamma == 1.500000,
+			"Incorrect gamma at task 56");
+	mu_assert(q->tasks[57]->gamma == 1.500000,
+			"Incorrect gamma at task 57");
+	mu_assert(q->tasks[58]->gamma == 1.500000,
+			"Incorrect gamma at task 58");
+	mu_assert(q->tasks[59]->gamma == 1.500000,
+			"Incorrect gamma at task 59");
+	mu_assert(q->tasks[60]->gamma == 0.500000,
+			"Incorrect gamma at task 60");
+	mu_assert(q->tasks[61]->gamma == 0.500000,
+			"Incorrect gamma at task 61");
+	mu_assert(q->tasks[62]->gamma == 0.500000,
+			"Incorrect gamma at task 62");
+	mu_assert(q->tasks[63]->gamma == 0.500000,
+			"Incorrect gamma at task 63");
+	mu_assert(q->tasks[64]->gamma == 0.500000,
+			"Incorrect gamma at task 64");
+	mu_assert(q->tasks[65]->gamma == 0.500000,
+			"Incorrect gamma at task 65");
+	mu_assert(q->tasks[66]->gamma == 1.500000,
+			"Incorrect gamma at task 66");
+	mu_assert(q->tasks[67]->gamma == 1.500000,
+			"Incorrect gamma at task 67");
+	mu_assert(q->tasks[68]->gamma == 1.500000,
+			"Incorrect gamma at task 68");
+	mu_assert(q->tasks[69]->gamma == 1.500000,
+			"Incorrect gamma at task 69");
+	mu_assert(q->tasks[70]->gamma == 1.500000,
+			"Incorrect gamma at task 70");
+	mu_assert(q->tasks[71]->gamma == 1.500000,
+			"Incorrect gamma at task 71");
+
+	mu_assert(q->tasks[0]->coef == 7.000000,
+			"Incorrect coef at task 0");
+	mu_assert(q->tasks[1]->coef == 7.000000,
+			"Incorrect coef at task 1");
+	mu_assert(q->tasks[2]->coef == 7.000000,
+			"Incorrect coef at task 2");
+	mu_assert(q->tasks[3]->coef == 7.000000,
+			"Incorrect coef at task 3");
+	mu_assert(q->tasks[4]->coef == 7.000000,
+			"Incorrect coef at task 4");
+	mu_assert(q->tasks[5]->coef == 7.000000,
+			"Incorrect coef at task 5");
+	mu_assert(q->tasks[6]->coef == 7.000000,
+			"Incorrect coef at task 6");
+	mu_assert(q->tasks[7]->coef == 7.000000,
+			"Incorrect coef at task 7");
+	mu_assert(q->tasks[8]->coef == 7.000000,
+			"Incorrect coef at task 8");
+	mu_assert(q->tasks[9]->coef == 7.000000,
+			"Incorrect coef at task 9");
+	mu_assert(q->tasks[10]->coef == 7.000000,
+			"Incorrect coef at task 10");
+	mu_assert(q->tasks[11]->coef == 7.000000,
+			"Incorrect coef at task 11");
+	mu_assert(q->tasks[12]->coef == 11.000000,
+			"Incorrect coef at task 12");
+	mu_assert(q->tasks[13]->coef == 11.000000,
+			"Incorrect coef at task 13");
+	mu_assert(q->tasks[14]->coef == 11.000000,
+			"Incorrect coef at task 14");
+	mu_assert(q->tasks[15]->coef == 11.000000,
+			"Incorrect coef at task 15");
+	mu_assert(q->tasks[16]->coef == 11.000000,
+			"Incorrect coef at task 16");
+	mu_assert(q->tasks[17]->coef == 11.000000,
+			"Incorrect coef at task 17");
+	mu_assert(q->tasks[18]->coef == 11.000000,
+			"Incorrect coef at task 18");
+	mu_assert(q->tasks[19]->coef == 11.000000,
+			"Incorrect coef at task 19");
+	mu_assert(q->tasks[20]->coef == 11.000000,
+			"Incorrect coef at task 20");
+	mu_assert(q->tasks[21]->coef == 11.000000,
+			"Incorrect coef at task 21");
+	mu_assert(q->tasks[22]->coef == 11.000000,
+			"Incorrect coef at task 22");
+	mu_assert(q->tasks[23]->coef == 11.000000,
+			"Incorrect coef at task 23");
+	mu_assert(q->tasks[24]->coef == 13.000000,
+			"Incorrect coef at task 24");
+	mu_assert(q->tasks[25]->coef == 13.000000,
+			"Incorrect coef at task 25");
+	mu_assert(q->tasks[26]->coef == 13.000000,
+			"Incorrect coef at task 26");
+	mu_assert(q->tasks[27]->coef == 13.000000,
+			"Incorrect coef at task 27");
+	mu_assert(q->tasks[28]->coef == 13.000000,
+			"Incorrect coef at task 28");
+	mu_assert(q->tasks[29]->coef == 13.000000,
+			"Incorrect coef at task 29");
+	mu_assert(q->tasks[30]->coef == 13.000000,
+			"Incorrect coef at task 30");
+	mu_assert(q->tasks[31]->coef == 13.000000,
+			"Incorrect coef at task 31");
+	mu_assert(q->tasks[32]->coef == 13.000000,
+			"Incorrect coef at task 32");
+	mu_assert(q->tasks[33]->coef == 13.000000,
+			"Incorrect coef at task 33");
+	mu_assert(q->tasks[34]->coef == 13.000000,
+			"Incorrect coef at task 34");
+	mu_assert(q->tasks[35]->coef == 13.000000,
+			"Incorrect coef at task 35");
+	mu_assert(q->tasks[36]->coef == 7.000000,
+			"Incorrect coef at task 36");
+	mu_assert(q->tasks[37]->coef == 7.000000,
+			"Incorrect coef at task 37");
+	mu_assert(q->tasks[38]->coef == 7.000000,
+			"Incorrect coef at task 38");
+	mu_assert(q->tasks[39]->coef == 7.000000,
+			"Incorrect coef at task 39");
+	mu_assert(q->tasks[40]->coef == 7.000000,
+			"Incorrect coef at task 40");
+	mu_assert(q->tasks[41]->coef == 7.000000,
+			"Incorrect coef at task 41");
+	mu_assert(q->tasks[42]->coef == 7.000000,
+			"Incorrect coef at task 42");
+	mu_assert(q->tasks[43]->coef == 7.000000,
+			"Incorrect coef at task 43");
+	mu_assert(q->tasks[44]->coef == 7.000000,
+			"Incorrect coef at task 44");
+	mu_assert(q->tasks[45]->coef == 7.000000,
+			"Incorrect coef at task 45");
+	mu_assert(q->tasks[46]->coef == 7.000000,
+			"Incorrect coef at task 46");
+	mu_assert(q->tasks[47]->coef == 7.000000,
+			"Incorrect coef at task 47");
+	mu_assert(q->tasks[48]->coef == 11.000000,
+			"Incorrect coef at task 48");
+	mu_assert(q->tasks[49]->coef == 11.000000,
+			"Incorrect coef at task 49");
+	mu_assert(q->tasks[50]->coef == 11.000000,
+			"Incorrect coef at task 50");
+	mu_assert(q->tasks[51]->coef == 11.000000,
+			"Incorrect coef at task 51");
+	mu_assert(q->tasks[52]->coef == 11.000000,
+			"Incorrect coef at task 52");
+	mu_assert(q->tasks[53]->coef == 11.000000,
+			"Incorrect coef at task 53");
+	mu_assert(q->tasks[54]->coef == 11.000000,
+			"Incorrect coef at task 54");
+	mu_assert(q->tasks[55]->coef == 11.000000,
+			"Incorrect coef at task 55");
+	mu_assert(q->tasks[56]->coef == 11.000000,
+			"Incorrect coef at task 56");
+	mu_assert(q->tasks[57]->coef == 11.000000,
+			"Incorrect coef at task 57");
+	mu_assert(q->tasks[58]->coef == 11.000000,
+			"Incorrect coef at task 58");
+	mu_assert(q->tasks[59]->coef == 11.000000,
+			"Incorrect coef at task 59");
+	mu_assert(q->tasks[60]->coef == 13.000000,
+			"Incorrect coef at task 60");
+	mu_assert(q->tasks[61]->coef == 13.000000,
+			"Incorrect coef at task 61");
+	mu_assert(q->tasks[62]->coef == 13.000000,
+			"Incorrect coef at task 62");
+	mu_assert(q->tasks[63]->coef == 13.000000,
+			"Incorrect coef at task 63");
+	mu_assert(q->tasks[64]->coef == 13.000000,
+			"Incorrect coef at task 64");
+	mu_assert(q->tasks[65]->coef == 13.000000,
+			"Incorrect coef at task 65");
+	mu_assert(q->tasks[66]->coef == 13.000000,
+			"Incorrect coef at task 66");
+	mu_assert(q->tasks[67]->coef == 13.000000,
+			"Incorrect coef at task 67");
+	mu_assert(q->tasks[68]->coef == 13.000000,
+			"Incorrect coef at task 68");
+	mu_assert(q->tasks[69]->coef == 13.000000,
+			"Incorrect coef at task 69");
+	mu_assert(q->tasks[70]->coef == 13.000000,
+			"Incorrect coef at task 70");
+	mu_assert(q->tasks[71]->coef == 13.000000,
+			"Incorrect coef at task 71");
+
+	mu_assert(q->tasks[0]->degree == 3.000000,
+			"Incorrect degree at task 0");
+	mu_assert(q->tasks[1]->degree == 3.000000,
+			"Incorrect degree at task 1");
+	mu_assert(q->tasks[2]->degree == 3.000000,
+			"Incorrect degree at task 2");
+	mu_assert(q->tasks[3]->degree == 3.000000,
+			"Incorrect degree at task 3");
+	mu_assert(q->tasks[4]->degree == 3.000000,
+			"Incorrect degree at task 4");
+	mu_assert(q->tasks[5]->degree == 3.000000,
+			"Incorrect degree at task 5");
+	mu_assert(q->tasks[6]->degree == 3.000000,
+			"Incorrect degree at task 6");
+	mu_assert(q->tasks[7]->degree == 3.000000,
+			"Incorrect degree at task 7");
+	mu_assert(q->tasks[8]->degree == 3.000000,
+			"Incorrect degree at task 8");
+	mu_assert(q->tasks[9]->degree == 3.000000,
+			"Incorrect degree at task 9");
+	mu_assert(q->tasks[10]->degree == 3.000000,
+			"Incorrect degree at task 10");
+	mu_assert(q->tasks[11]->degree == 3.000000,
+			"Incorrect degree at task 11");
+	mu_assert(q->tasks[12]->degree == 3.000000,
+			"Incorrect degree at task 12");
+	mu_assert(q->tasks[13]->degree == 3.000000,
+			"Incorrect degree at task 13");
+	mu_assert(q->tasks[14]->degree == 3.000000,
+			"Incorrect degree at task 14");
+	mu_assert(q->tasks[15]->degree == 3.000000,
+			"Incorrect degree at task 15");
+	mu_assert(q->tasks[16]->degree == 3.000000,
+			"Incorrect degree at task 16");
+	mu_assert(q->tasks[17]->degree == 3.000000,
+			"Incorrect degree at task 17");
+	mu_assert(q->tasks[18]->degree == 3.000000,
+			"Incorrect degree at task 18");
+	mu_assert(q->tasks[19]->degree == 3.000000,
+			"Incorrect degree at task 19");
+	mu_assert(q->tasks[20]->degree == 3.000000,
+			"Incorrect degree at task 20");
+	mu_assert(q->tasks[21]->degree == 3.000000,
+			"Incorrect degree at task 21");
+	mu_assert(q->tasks[22]->degree == 3.000000,
+			"Incorrect degree at task 22");
+	mu_assert(q->tasks[23]->degree == 3.000000,
+			"Incorrect degree at task 23");
+	mu_assert(q->tasks[24]->degree == 3.000000,
+			"Incorrect degree at task 24");
+	mu_assert(q->tasks[25]->degree == 3.000000,
+			"Incorrect degree at task 25");
+	mu_assert(q->tasks[26]->degree == 3.000000,
+			"Incorrect degree at task 26");
+	mu_assert(q->tasks[27]->degree == 3.000000,
+			"Incorrect degree at task 27");
+	mu_assert(q->tasks[28]->degree == 3.000000,
+			"Incorrect degree at task 28");
+	mu_assert(q->tasks[29]->degree == 3.000000,
+			"Incorrect degree at task 29");
+	mu_assert(q->tasks[30]->degree == 3.000000,
+			"Incorrect degree at task 30");
+	mu_assert(q->tasks[31]->degree == 3.000000,
+			"Incorrect degree at task 31");
+	mu_assert(q->tasks[32]->degree == 3.000000,
+			"Incorrect degree at task 32");
+	mu_assert(q->tasks[33]->degree == 3.000000,
+			"Incorrect degree at task 33");
+	mu_assert(q->tasks[34]->degree == 3.000000,
+			"Incorrect degree at task 34");
+	mu_assert(q->tasks[35]->degree == 3.000000,
+			"Incorrect degree at task 35");
+	mu_assert(q->tasks[36]->degree == 5.000000,
+			"Incorrect degree at task 36");
+	mu_assert(q->tasks[37]->degree == 5.000000,
+			"Incorrect degree at task 37");
+	mu_assert(q->tasks[38]->degree == 5.000000,
+			"Incorrect degree at task 38");
+	mu_assert(q->tasks[39]->degree == 5.000000,
+			"Incorrect degree at task 39");
+	mu_assert(q->tasks[40]->degree == 5.000000,
+			"Incorrect degree at task 40");
+	mu_assert(q->tasks[41]->degree == 5.000000,
+			"Incorrect degree at task 41");
+	mu_assert(q->tasks[42]->degree == 5.000000,
+			"Incorrect degree at task 42");
+	mu_assert(q->tasks[43]->degree == 5.000000,
+			"Incorrect degree at task 43");
+	mu_assert(q->tasks[44]->degree == 5.000000,
+			"Incorrect degree at task 44");
+	mu_assert(q->tasks[45]->degree == 5.000000,
+			"Incorrect degree at task 45");
+	mu_assert(q->tasks[46]->degree == 5.000000,
+			"Incorrect degree at task 46");
+	mu_assert(q->tasks[47]->degree == 5.000000,
+			"Incorrect degree at task 47");
+	mu_assert(q->tasks[48]->degree == 5.000000,
+			"Incorrect degree at task 48");
+	mu_assert(q->tasks[49]->degree == 5.000000,
+			"Incorrect degree at task 49");
+	mu_assert(q->tasks[50]->degree == 5.000000,
+			"Incorrect degree at task 50");
+	mu_assert(q->tasks[51]->degree == 5.000000,
+			"Incorrect degree at task 51");
+	mu_assert(q->tasks[52]->degree == 5.000000,
+			"Incorrect degree at task 52");
+	mu_assert(q->tasks[53]->degree == 5.000000,
+			"Incorrect degree at task 53");
+	mu_assert(q->tasks[54]->degree == 5.000000,
+			"Incorrect degree at task 54");
+	mu_assert(q->tasks[55]->degree == 5.000000,
+			"Incorrect degree at task 55");
+	mu_assert(q->tasks[56]->degree == 5.000000,
+			"Incorrect degree at task 56");
+	mu_assert(q->tasks[57]->degree == 5.000000,
+			"Incorrect degree at task 57");
+	mu_assert(q->tasks[58]->degree == 5.000000,
+			"Incorrect degree at task 58");
+	mu_assert(q->tasks[59]->degree == 5.000000,
+			"Incorrect degree at task 59");
+	mu_assert(q->tasks[60]->degree == 5.000000,
+			"Incorrect degree at task 60");
+	mu_assert(q->tasks[61]->degree == 5.000000,
+			"Incorrect degree at task 61");
+	mu_assert(q->tasks[62]->degree == 5.000000,
+			"Incorrect degree at task 62");
+	mu_assert(q->tasks[63]->degree == 5.000000,
+			"Incorrect degree at task 63");
+	mu_assert(q->tasks[64]->degree == 5.000000,
+			"Incorrect degree at task 64");
+	mu_assert(q->tasks[65]->degree == 5.000000,
+			"Incorrect degree at task 65");
+	mu_assert(q->tasks[66]->degree == 5.000000,
+			"Incorrect degree at task 66");
+	mu_assert(q->tasks[67]->degree == 5.000000,
+			"Incorrect degree at task 67");
+	mu_assert(q->tasks[68]->degree == 5.000000,
+			"Incorrect degree at task 68");
+	mu_assert(q->tasks[69]->degree == 5.000000,
+			"Incorrect degree at task 69");
+	mu_assert(q->tasks[70]->degree == 5.000000,
+			"Incorrect degree at task 70");
+	mu_assert(q->tasks[71]->degree == 5.000000,
+			"Incorrect degree at task 71");
 	gensvm_free_queue(q);
 	// end test code //
 
@@ -871,53 +871,41 @@ char *test_kernel_changed()
 
 	// rbf kernel
 	old->kerneltype = K_RBF;
-	old->kernelparam = Malloc(double, 1);
-	old->kernelparam[0] = 1.0;
-	new->kernelparam = Malloc(double, 1);
-	new->kernelparam[0] = 1.0;
+	old->gamma = 1.0;
+	new->gamma = 1.0;
 	mu_assert(gensvm_kernel_changed(new, old) == false,
 			"Incorrect kernel changed (4)");
-	new->kernelparam[0] = 2.0;
+	new->gamma = 2.0;
 	mu_assert(gensvm_kernel_changed(new, old) == true,
 			"Incorrect kernel changed (5)");
 
-	free(old->kernelparam);
-	free(new->kernelparam);
-
 	// poly kernel
 	old->kerneltype = K_POLY;
 	new->kerneltype = K_POLY;
-	old->kernelparam = Malloc(double, 3);
-	old->kernelparam[0] = 1.0;
-	old->kernelparam[1] = 2.0;
-	old->kernelparam[2] = 3.0;
-
-	new->kernelparam = Malloc(double, 3);
-	new->kernelparam[0] = 1.0;
-	new->kernelparam[1] = 2.0;
-	new->kernelparam[2] = 3.0;
+	old->gamma = 1.0;
+	old->coef = 2.0;
+	old->degree = 3.0;
+
+	new->gamma = 1.0;
+	new->coef = 2.0;
+	new->degree = 3.0;
 	mu_assert(gensvm_kernel_changed(new, old) == false,
 			"Incorrect kernel changed (6)");
-	new->kernelparam[2] = 5.0;
+	new->degree = 5.0;
 	mu_assert(gensvm_kernel_changed(new, old) == true,
 			"Incorrect kernel changed (7)");
 
-	free(old->kernelparam);
-	free(new->kernelparam);
-
 	// sigmoid kernel
 	old->kerneltype = K_SIGMOID;
 	new->kerneltype = K_SIGMOID;
-	old->kernelparam = Malloc(double, 2);
-	old->kernelparam[0] = 1.0;
-	old->kernelparam[1] = 2.0;
-	new->kernelparam = Malloc(double, 2);
-	new->kernelparam[0] = 1.0;
-	new->kernelparam[1] = 2.0;
+	old->gamma = 1.0;
+	old->coef = 2.0;
+	new->gamma = 1.0;
+	new->coef = 2.0;
 
 	mu_assert(gensvm_kernel_changed(new, old) == false,
 			"Incorrect kernel changed (8)");
-	new->kernelparam[1] = 5.0;
+	new->coef = 5.0;
 	mu_assert(gensvm_kernel_changed(new, old) == true,
 			"Incorrect kernel changed (9)");
 
@@ -980,8 +968,7 @@ char *test_gridsearch_progress_rbf()
 	struct GenTask *task = gensvm_init_task();
 	task->ID = 0;
 	task->kerneltype = K_RBF;
-	task->kernelparam = Malloc(double, 1);
-	task->kernelparam[0] = 3.0;
+	task->gamma = 3.0;
 
 	// start test code //
 	gensvm_gridsearch_progress(task, 10, 0.5, 0.123, 0.7);
@@ -1012,10 +999,9 @@ char *test_gridsearch_progress_poly()
 	struct GenTask *task = gensvm_init_task();
 	task->ID = 0;
 	task->kerneltype = K_POLY;
-	task->kernelparam = Malloc(double, 3);
-	task->kernelparam[0] = 3.0;
-	task->kernelparam[1] = 1.0;
-	task->kernelparam[2] = 2.0;
+	task->gamma = 3.0;
+	task->coef = 1.0;
+	task->degree = 2.0;
 
 	// start test code //
 	gensvm_gridsearch_progress(task, 10, 0.5, 0.123, 0.7);
@@ -1048,9 +1034,8 @@ char *test_gridsearch_progress_sigmoid()
 	struct GenTask *task = gensvm_init_task();
 	task->ID = 0;
 	task->kerneltype = K_SIGMOID;
-	task->kernelparam = Malloc(double, 2);
-	task->kernelparam[0] = 3.0;
-	task->kernelparam[1] = 1.0;
+	task->gamma = 3.0;
+	task->coef = 1.0;
 
 	// start test code //
 	gensvm_gridsearch_progress(task, 10, 0.5, 0.123, 0.7);
diff --git a/tests/src/test_gensvm_kernel.c b/tests/src/test_gensvm_kernel.c
index 219d510..cf1d4db 100644
--- a/tests/src/test_gensvm_kernel.c
+++ b/tests/src/test_gensvm_kernel.c
@@ -39,7 +39,6 @@ char *test_kernel_copy_kernelparam_to_data_linear()
 	gensvm_kernel_copy_kernelparam_to_data(model, data);
 
 	mu_assert(data->kerneltype == K_LINEAR, "Incorrect data kerneltype");
-	mu_assert(data->kernelparam == NULL, "Incorrect data kernelparam");
 	// end test code //
 
 	gensvm_free_data(data);
@@ -54,13 +53,12 @@ char *test_kernel_copy_kernelparam_to_data_rbf()
 	struct GenData *data = gensvm_init_data();
 
 	model->kerneltype = K_RBF;
-	model->kernelparam = Calloc(double, 1);
-	model->kernelparam[0] = 1.23;
+	model->gamma = 1.23;
 
 	// start test code //
 	gensvm_kernel_copy_kernelparam_to_data(model, data);
 	mu_assert(data->kerneltype == K_RBF, "Incorrect data->kerneltype");
-	mu_assert(data->kernelparam[0] == 1.23, "Incorrect data->kernelparam[0]");
+	mu_assert(data->gamma == 1.23, "Incorrect data->gamma");
 
 	// end test code //
 
@@ -76,17 +74,16 @@ char *test_kernel_copy_kernelparam_to_data_poly()
 	struct GenData *data = gensvm_init_data();
 
 	model->kerneltype = K_POLY;
-	model->kernelparam = Calloc(double, 3);
-	model->kernelparam[0] = 1.23;
-	model->kernelparam[1] = 2.23;
-	model->kernelparam[2] = 3.23;
+	model->gamma = 1.23;
+	model->coef = 2.23;
+	model->degree = 3.23;
 
 	// start test code //
 	gensvm_kernel_copy_kernelparam_to_data(model, data);
 	mu_assert(data->kerneltype == K_POLY, "Incorrect data->kerneltype");
-	mu_assert(data->kernelparam[0] == 1.23, "Incorrect data->kernelparam[0]");
-	mu_assert(data->kernelparam[1] == 2.23, "Incorrect data->kernelparam[1]");
-	mu_assert(data->kernelparam[2] == 3.23, "Incorrect data->kernelparam[2]");
+	mu_assert(data->gamma == 1.23, "Incorrect data->gamma");
+	mu_assert(data->coef == 2.23, "Incorrect data->coef");
+	mu_assert(data->degree == 3.23, "Incorrect data->degree");
 
 	// end test code //
 
@@ -102,15 +99,14 @@ char *test_kernel_copy_kernelparam_to_data_sigmoid()
 	struct GenData *data = gensvm_init_data();
 
 	model->kerneltype = K_SIGMOID;
-	model->kernelparam = Calloc(double, 2);
-	model->kernelparam[0] = 1.23;
-	model->kernelparam[1] = 2.23;
+	model->gamma = 1.23;
+	model->coef = 2.23;
 
 	// start test code //
 	gensvm_kernel_copy_kernelparam_to_data(model, data);
 	mu_assert(data->kerneltype == K_SIGMOID, "Incorrect data->kerneltype");
-	mu_assert(data->kernelparam[0] == 1.23, "Incorrect data->kernelparam[0]");
-	mu_assert(data->kernelparam[1] == 2.23, "Incorrect data->kernelparam[1]");
+	mu_assert(data->gamma == 1.23, "Incorrect data->gamma");
+	mu_assert(data->coef == 2.23, "Incorrect data->coef");
 
 	// end test code //
 
@@ -122,10 +118,9 @@ char *test_kernel_copy_kernelparam_to_data_sigmoid()
 
 char *test_dot_rbf()
 {
-	double dot;
+	double dot, gamma;
 	double *a = Malloc(double, 5);
 	double *b = Malloc(double, 5);
-	double *kernelparam = Malloc(double, 1);
 
 	a[0] = 0.5203363837176203;
 	a[1] = 0.3860628599460129;
@@ -140,28 +135,26 @@ char *test_dot_rbf()
 	b[4] = 0.8805451245738238;
 
 	// start test code //
-	kernelparam[0] = 1.0;
-	dot = gensvm_kernel_dot_rbf(a, b, kernelparam, 5);
+	gamma = 1.0;
+	dot = gensvm_kernel_dot_rbf(a, b, 5, gamma);
 	mu_assert(fabs(dot - 0.657117701533133) < 1e-14, "Incorrect dot (1)");
 
-	kernelparam[0] = 5.0;
-	dot = gensvm_kernel_dot_rbf(a, b, kernelparam, 5);
+	gamma = 5.0;
+	dot = gensvm_kernel_dot_rbf(a, b, 5, gamma);
 	mu_assert(fabs(dot - 0.122522495044048) < 1e-14, "Incorrect dot (2)");
 
 	// end test code //
 	free(a);
 	free(b);
-	free(kernelparam);
 
 	return NULL;
 }
 
 char *test_dot_poly()
 {
-	double dot;
+	double dot, gamma, coef, degree;
 	double *a = Malloc(double, 5);
 	double *b = Malloc(double, 5);
-	double *kernelparam = Malloc(double, 3);
 
 	a[0] = 0.5203363837176203;
 	a[1] = 0.3860628599460129;
@@ -176,31 +169,29 @@ char *test_dot_poly()
 	b[4] = 0.8805451245738238;
 
 	// start test code //
-	kernelparam[0] = 1.0;
-	kernelparam[1] = 1.0;
-	kernelparam[2] = 1.0;
-	dot = gensvm_kernel_dot_poly(a, b, kernelparam, 5);
+	gamma = 1.0;
+	coef = 1.0;
+	degree = 1.0;
+	dot = gensvm_kernel_dot_poly(a, b, 5, gamma, coef, degree);
 	mu_assert(fabs(dot - 2.31723456944910) < 1e-14, "Incorrect dot (1)");
 
-	kernelparam[0] = 1.5;
-	kernelparam[1] = 2.5;
-	kernelparam[2] = 3.5;
-	dot = gensvm_kernel_dot_poly(a, b, kernelparam, 5);
+	gamma = 1.5;
+	coef = 2.5;
+	degree = 3.5;
+	dot = gensvm_kernel_dot_poly(a, b, 5, gamma, coef, degree);
 	mu_assert(fabs(dot - 189.6989652572890179) < 1e-14, "Incorrect dot (2)");
 
 	// end test code //
 	free(a);
 	free(b);
-	free(kernelparam);
 	return NULL;
 }
 
 char *test_dot_sigmoid()
 {
-	double dot;
+	double dot, gamma, coef;
 	double *a = Malloc(double, 5);
 	double *b = Malloc(double, 5);
-	double *kernelparam = Malloc(double, 2);
 
 	a[0] = 0.5203363837176203;
 	a[1] = 0.3860628599460129;
@@ -215,20 +206,19 @@ char *test_dot_sigmoid()
 	b[4] = 0.8805451245738238;
 
 	// start test code //
-	kernelparam[0] = 1.0;
-	kernelparam[1] = 1.0;
-	dot = gensvm_kernel_dot_sigmoid(a, b, kernelparam, 5);
+	gamma = 1.0;
+	coef = 1.0;
+	dot = gensvm_kernel_dot_sigmoid(a, b, 5, gamma, coef);
 	mu_assert(fabs(dot - 0.9807642810850747) < 1e-14, "Incorrect dot (1)");
 
-	kernelparam[0] = 1.5;
-	kernelparam[1] = 2.5;
-	dot = gensvm_kernel_dot_sigmoid(a, b, kernelparam, 5);
+	gamma = 1.5;
+	coef = 2.5;
+	dot = gensvm_kernel_dot_sigmoid(a, b, 5, gamma, coef);
 	mu_assert(fabs(dot - 0.9997410009167159) < 1e-14, "Incorrect dot (2)");
 
 	// end test code //
 	free(a);
 	free(b);
-	free(kernelparam);
 
 	return NULL;
 }
@@ -263,8 +253,7 @@ char *test_kernel_preprocess_kernel()
 	data->m = 5;
 
 	model->kerneltype = K_RBF;
-	model->kernelparam = Calloc(double, 1);
-	model->kernelparam[0] = 0.348;
+	model->gamma = 0.348;
 	model->kernel_eigen_cutoff = 5e-3;
 
 	data->Z = Calloc(double, data->n * (data->m + 1));
@@ -811,8 +800,7 @@ char *test_kernel_postprocess_kernel()
 	test->RAW = Calloc(double, test->n * (test->m + 1));
 
 	model->kerneltype = K_RBF;
-	model->kernelparam = Calloc(double, 1);
-	model->kernelparam[0] = 1.132;
+	model->gamma = 1.132;
 
 	// start test code //
 
@@ -1104,8 +1092,7 @@ char *test_kernel_compute_rbf()
 	model->n = 10;
 	model->m = 3;
 	model->kerneltype = K_RBF;
-	model->kernelparam = Calloc(double, 1);
-	model->kernelparam[0] = 0.348;
+	model->gamma = 0.348;
 
 	double *K = Calloc(double, data->n * data->n);
 
@@ -1479,10 +1466,9 @@ char *test_kernel_compute_poly()
 	model->n = 10;
 	model->m = 3;
 	model->kerneltype = K_POLY;
-	model->kernelparam = Calloc(double, 3);
-	model->kernelparam[0] = 1.5;
-	model->kernelparam[1] = 3.0;
-	model->kernelparam[2] = 1.78;
+	model->gamma = 1.5;
+	model->coef = 3.0;
+	model->degree = 1.78;
 
 	double *K = Calloc(double, data->n * data->n);
 
@@ -1855,9 +1841,8 @@ char *test_kernel_compute_sigmoid()
 	model->n = 10;
 	model->m = 3;
 	model->kerneltype = K_SIGMOID;
-	model->kernelparam = Calloc(double, 3);
-	model->kernelparam[0] = 1.23;
-	model->kernelparam[1] = 1.6;
+	model->gamma = 1.23;
+	model->coef = 1.6;
 
 	double *K = Calloc(double, data->n * data->n);
 
@@ -2328,7 +2313,7 @@ char *test_kernel_eigendecomp()
 	double *P = NULL;
 	double *Sigma = NULL;
 	long r = gensvm_kernel_eigendecomp(K, n, 1e-2, &P, &Sigma);
-	double eps = 1e-14;
+	double eps = 1e-13;
 
 	mu_assert(r == 7, "Incorrect number of eigenvalues kept");
 
@@ -2589,8 +2574,7 @@ char *test_kernel_cross_rbf()
 	model->n = 10;
 	model->m = 3;
 	model->kerneltype = K_RBF;
-	model->kernelparam = Calloc(double, 1);
-	model->kernelparam[0] = 0.348;
+	model->gamma = 0.348;
 
 	matrix_set(data_1->RAW, data_1->m+1, 0, 0, 1.0000000000000000);
 	matrix_set(data_1->RAW, data_1->m+1, 0, 1, 0.8056271362589000);
@@ -2836,10 +2820,9 @@ char *test_kernel_cross_poly()
 	model->n = 10;
 	model->m = 3;
 	model->kerneltype = K_POLY;
-	model->kernelparam = Calloc(double, 3);
-	model->kernelparam[0] = 1.5;
-	model->kernelparam[1] = 3.0;
-	model->kernelparam[2] = 1.78;
+	model->gamma = 1.5;
+	model->coef = 3.0;
+	model->degree = 1.78;
 
 	matrix_set(data_1->RAW, data_1->m+1, 0, 0, 1.0000000000000000);
 	matrix_set(data_1->RAW, data_1->m+1, 0, 1, 0.8056271362589000);
@@ -3085,9 +3068,8 @@ char *test_kernel_cross_sigmoid()
 	model->n = 10;
 	model->m = 3;
 	model->kerneltype = K_SIGMOID;
-	model->kernelparam = Calloc(double, 3);
-	model->kernelparam[0] = 1.23;
-	model->kernelparam[1] = 1.6;
+	model->gamma = 1.23;
+	model->coef = 1.6;
 
 	matrix_set(data_1->RAW, data_1->m+1, 0, 0, 1.0000000000000000);
 	matrix_set(data_1->RAW, data_1->m+1, 0, 1, 0.8056271362589000);
diff --git a/tests/src/test_gensvm_task.c b/tests/src/test_gensvm_task.c
index e3e66da..3966d1f 100644
--- a/tests/src/test_gensvm_task.c
+++ b/tests/src/test_gensvm_task.c
@@ -55,7 +55,6 @@ char *test_task_to_model_linear()
 	mu_assert(model->lambda == 1.4, "Incorrect model lambda");
 	mu_assert(model->epsilon == 5e-3, "Incorrect model epsilon");
 	mu_assert(model->kerneltype == K_LINEAR, "Incorrect model kerneltype");
-	mu_assert(model->kernelparam == NULL, "Incorrect model kernelparam");
 	// end test code //
 
 	gensvm_free_model(model);
@@ -75,8 +74,7 @@ char *test_task_to_model_rbf()
 	task->lambda = 1.4;
 	task->epsilon = 5e-3;
 	task->kerneltype = K_RBF;
-	task->kernelparam = Malloc(double, 1);
-	task->kernelparam[0] = 3.1;
+	task->gamma = 3.1;
 
 	gensvm_task_to_model(task, model);
 
@@ -86,7 +84,7 @@ char *test_task_to_model_rbf()
 	mu_assert(model->lambda == 1.4, "Incorrect model lambda");
 	mu_assert(model->epsilon == 5e-3, "Incorrect model epsilon");
 	mu_assert(model->kerneltype == K_RBF, "Incorrect model kerneltype");
-	mu_assert(model->kernelparam[0] == 3.1, "Incorrect model kernelparam");
+	mu_assert(model->gamma == 3.1, "Incorrect model gamma");
 	// end test code //
 
 	gensvm_free_model(model);
@@ -106,10 +104,9 @@ char *test_task_to_model_poly()
 	task->lambda = 1.4;
 	task->epsilon = 5e-3;
 	task->kerneltype = K_POLY;
-	task->kernelparam = Malloc(double, 3);
-	task->kernelparam[0] = 3.1;
-	task->kernelparam[1] = 2.1;
-	task->kernelparam[2] = 1.1;
+	task->gamma = 3.1;
+	task->coef = 2.1;
+	task->degree = 1.1;
 
 	gensvm_task_to_model(task, model);
 
@@ -119,9 +116,9 @@ char *test_task_to_model_poly()
 	mu_assert(model->lambda == 1.4, "Incorrect model lambda");
 	mu_assert(model->epsilon == 5e-3, "Incorrect model epsilon");
 	mu_assert(model->kerneltype == K_POLY, "Incorrect model kerneltype");
-	mu_assert(model->kernelparam[0] == 3.1, "Incorrect model kernelparam");
-	mu_assert(model->kernelparam[1] == 2.1, "Incorrect model kernelparam");
-	mu_assert(model->kernelparam[2] == 1.1, "Incorrect model kernelparam");
+	mu_assert(model->gamma == 3.1, "Incorrect model gamma");
+	mu_assert(model->coef == 2.1, "Incorrect model coef");
+	mu_assert(model->degree == 1.1, "Incorrect model degree");
 	// end test code //
 
 	gensvm_free_model(model);
@@ -141,9 +138,8 @@ char *test_task_to_model_sigmoid()
 	task->lambda = 1.4;
 	task->epsilon = 5e-3;
 	task->kerneltype = K_SIGMOID;
-	task->kernelparam = Malloc(double, 2);
-	task->kernelparam[0] = 3.1;
-	task->kernelparam[1] = 0.1;
+	task->gamma = 3.1;
+	task->coef = 0.1;
 
 	gensvm_task_to_model(task, model);
 
@@ -153,8 +149,8 @@ char *test_task_to_model_sigmoid()
 	mu_assert(model->lambda == 1.4, "Incorrect model lambda");
 	mu_assert(model->epsilon == 5e-3, "Incorrect model epsilon");
 	mu_assert(model->kerneltype == K_SIGMOID, "Incorrect model kerneltype");
-	mu_assert(model->kernelparam[0] == 3.1, "Incorrect model kernelparam");
-	mu_assert(model->kernelparam[1] == 0.1, "Incorrect model kernelparam");
+	mu_assert(model->gamma == 3.1, "Incorrect model gamma");
+	mu_assert(model->coef == 0.1, "Incorrect model coef");
 	// end test code //
 
 	gensvm_free_model(model);
@@ -195,7 +191,6 @@ char *test_copy_task_linear()
 	mu_assert(copy->test_data == test, "Incorrect copy test data");
 	mu_assert(copy->performance == 11.11, "Incorrect copy performance");
 	mu_assert(copy->kerneltype == K_LINEAR, "Incorrect copy kerneltype");
-	mu_assert(copy->kernelparam == NULL, "Incorrect copy kernelparam");
 
 	// end test code //
 	gensvm_free_task(task);
@@ -226,8 +221,7 @@ char *test_copy_task_rbf()
 	task->test_data = test;
 	task->performance = 11.11;
 	task->kerneltype = K_RBF;
-	task->kernelparam = Malloc(double, 1);
-	task->kernelparam[0] = 3.1;
+	task->gamma = 3.1;
 
 	copy = gensvm_copy_task(task);
 
@@ -242,7 +236,7 @@ char *test_copy_task_rbf()
 	mu_assert(copy->test_data == test, "Incorrect copy test data");
 	mu_assert(copy->performance == 11.11, "Incorrect copy performance");
 	mu_assert(copy->kerneltype == K_RBF, "Incorrect copy kerneltype");
-	mu_assert(copy->kernelparam[0] == 3.1, "Incorrect copy kernelparam");
+	mu_assert(copy->gamma == 3.1, "Incorrect copy gamma");
 
 	// end test code //
 	gensvm_free_task(copy);
@@ -272,10 +266,9 @@ char *test_copy_task_poly()
 	task->test_data = test;
 	task->performance = 11.11;
 	task->kerneltype = K_POLY;
-	task->kernelparam = Malloc(double, 3);
-	task->kernelparam[0] = 3.1;
-	task->kernelparam[1] = 2.1;
-	task->kernelparam[2] = 1.1;
+	task->gamma = 3.1;
+	task->coef = 2.1;
+	task->degree = 1.1;
 
 	copy = gensvm_copy_task(task);
 
@@ -290,9 +283,9 @@ char *test_copy_task_poly()
 	mu_assert(copy->test_data == test, "Incorrect copy test data");
 	mu_assert(copy->performance == 11.11, "Incorrect copy performance");
 	mu_assert(copy->kerneltype == K_POLY, "Incorrect copy kerneltype");
-	mu_assert(copy->kernelparam[0] == 3.1, "Incorrect copy kernelparam");
-	mu_assert(copy->kernelparam[1] == 2.1, "Incorrect copy kernelparam");
-	mu_assert(copy->kernelparam[2] == 1.1, "Incorrect copy kernelparam");
+	mu_assert(copy->gamma == 3.1, "Incorrect copy gamma");
+	mu_assert(copy->coef == 2.1, "Incorrect copy coef");
+	mu_assert(copy->degree == 1.1, "Incorrect copy degree");
 
 	// end test code //
 	gensvm_free_task(task);
@@ -322,9 +315,8 @@ char *test_copy_task_sigmoid()
 	task->test_data = test;
 	task->performance = 11.11;
 	task->kerneltype = K_SIGMOID;
-	task->kernelparam = Malloc(double, 2);
-	task->kernelparam[0] = 3.1;
-	task->kernelparam[1] = 0.1;
+	task->gamma = 3.1;
+	task->coef = 0.1;
 
 	copy = gensvm_copy_task(task);
 
@@ -339,8 +331,8 @@ char *test_copy_task_sigmoid()
 	mu_assert(copy->test_data == test, "Incorrect copy test data");
 	mu_assert(copy->performance == 11.11, "Incorrect copy performance");
 	mu_assert(copy->kerneltype == K_SIGMOID, "Incorrect copy kerneltype");
-	mu_assert(copy->kernelparam[0] == 3.1, "Incorrect copy kernelparam");
-	mu_assert(copy->kernelparam[1] == 0.1, "Incorrect copy kernelparam");
+	mu_assert(copy->gamma == 3.1, "Incorrect copy gamma");
+	mu_assert(copy->coef == 0.1, "Incorrect copy coef");
 
 	// end test code //
 	gensvm_free_task(task);
diff --git a/tests/src/test_gensvm_train.c b/tests/src/test_gensvm_train.c
index 4994eb6..b95de28 100644
--- a/tests/src/test_gensvm_train.c
+++ b/tests/src/test_gensvm_train.c
@@ -180,8 +180,7 @@ char *test_gensvm_train_seed_kernel()
 	model->epsilon = 1e-15;
 	model->weight_idx = 1;
 	model->kerneltype = K_RBF;
-	model->kernelparam = Calloc(double, 1);
-	model->kernelparam[0] = 0.348;
+	model->gamma = 0.348;
 	model->kernel_eigen_cutoff = 5e-3;
 
 	data->n = 10;