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.

16 files changed, 690 insertions, 803 deletions

diff --git a/include/gensvm_base.h b/include/gensvm_base.h
index 999bf2f..dee1d80 100644
--- a/include/gensvm_base.h
+++ b/include/gensvm_base.h
@@ -49,7 +49,9 @@
  * @param J 		pointer to regularization vector
  * @param Sigma 	eigenvalues from the reduced eigendecomposition
  * @param kerneltype 	kerneltype used in GenData::Z
- * @param *kernelparam 	kernel parameters used in GenData::Z
+ * @param gamma 	kernel parameter for RBF, poly, and sigmoid
+ * @param coef 		kernel parameter for poly and sigmoid
+ * @param degree 	kernel parameter for poly
  *
  */
 struct GenData {
@@ -75,9 +77,12 @@ struct GenData {
 	KernelType kerneltype;
 	///< kerneltype used to generate the kernel corresponding to the data 
 	///< in Z
- 	double *kernelparam;
-	///< kernelparameters used to generate the kernel corresponding to the 
-	///< data in Z
+	double gamma;
+	///< kernel parameter for RBF, poly, and sigmoid
+	double coef;
+	///< kernel parameter for poly and sigmoid
+	double degree;
+	///< kernel parameter for poly
 };
 
 /**
@@ -101,6 +106,12 @@ struct GenModel {
 	///< parameter for the Huber hinge function
 	double lambda;
 	///< regularization parameter in the loss function
+	double gamma;
+	///< kernel parameter for RBF, poly, and sigmoid
+	double coef;
+	///< kernel parameter for poly and sigmoid
+	double degree;
+	///< kernel parameter for poly
 	double *V;
 	///< augmented weight matrix
 	double *Vbar;
@@ -122,8 +133,6 @@ struct GenModel {
 	///< filename of the data
 	KernelType kerneltype;
 	///< type of kernel used in the model
-	double *kernelparam;
-	///< array of kernel parameters, size depends on kernel type
 	double kernel_eigen_cutoff;
 	///< cutoff value for the ratio of eigenvalues in the reduced 
 	//eigendecomposition.
diff --git a/include/gensvm_kernel.h b/include/gensvm_kernel.h
index 1d4f0d1..bb3e100 100644
--- a/include/gensvm_kernel.h
+++ b/include/gensvm_kernel.h
@@ -51,12 +51,11 @@ void gensvm_kernel_trainfactor(struct GenData *data, double *P, double *Sigma,
 		long r);
 void gensvm_kernel_testfactor(struct GenData *testdata,
 	       	struct GenData *traindata, double *K2);
-double gensvm_kernel_dot_rbf(double *x1, double *x2, double *kernelparam,
-		long n);
-double gensvm_kernel_dot_poly(double *x1, double *x2, double *kernelparam,
-		long n);
-double gensvm_kernel_dot_sigmoid(double *x1, double *x2, double *kernelparam,
-		long n);
+double gensvm_kernel_dot_rbf(double *x1, double *x2, long n, double gamma);
+double gensvm_kernel_dot_poly(double *x1, double *x2, long n, double gamma, 
+		double coef, double degree);
+double gensvm_kernel_dot_sigmoid(double *x1, double *x2, long n, double gamma, 
+		double coef);
 int dsyevx(char JOBZ, char RANGE, char UPLO, int N, double *A, int LDA,
 	       	double VL, double VU, int IL, int IU, double ABSTOL,
 		int *M, double *W, double *Z, int LDZ, double *WORK, int LWORK,
diff --git a/include/gensvm_task.h b/include/gensvm_task.h
index 03fcbb5..a791262 100644
--- a/include/gensvm_task.h
+++ b/include/gensvm_task.h
@@ -45,7 +45,9 @@
  * @param lambda 	parameter for the GenModel
  * @param epsilon 	parameter for the GenModel
  * @param kerneltype 	parameter for the GenModel
- * @param kernelparam 	kernel parameters for the GenModel
+ * @param gamma 	parameter for the GenModel
+ * @param coef 		parameter for the GenModel
+ * @param degree 	parameter for the GenModel
  * @param train_data 	pointer to the training data
  * @param test_data 	pointer to the test data (if any)
  * @param performance 	performance after cross validation
@@ -67,8 +69,12 @@ struct GenTask {
 	///< lambda parameter for the GenModel
 	double epsilon;
 	///< epsilon parameter for the GenModel
-	double *kernelparam;
-	///< kernelparam parameters for the GenModel
+	double gamma;
+	///< gamma parameter for the GenModel
+	double coef;
+	///< coef parameter for the GenModel
+	double degree;
+	///< degree parameter for the GenModel
 	struct GenData *train_data;
 	///< pointer to the training data
 	struct GenData *test_data;
diff --git a/src/GenSVMtraintest.c b/src/GenSVMtraintest.c
index 0da45ec..285be2a 100644
--- a/src/GenSVMtraintest.c
+++ b/src/GenSVMtraintest.c
@@ -278,9 +278,6 @@ void parse_command_line(int argc, char **argv, struct GenModel *model,
 	       	char **prediction_outputfile)
 {
 	int i;
-	double gamma = 1.0,
-	       degree = 2.0,
-	       coef = 0.0;
 
 	GENSVM_OUTPUT_FILE = stdout;
 	GENSVM_ERROR_FILE = stderr;
@@ -294,10 +291,10 @@ void parse_command_line(int argc, char **argv, struct GenModel *model,
 		}
 		switch (argv[i-1][1]) {
 			case 'c':
-				coef = atof(argv[i]);
+				model->coef = atof(argv[i]);
 				break;
 			case 'd':
-				degree = atof(argv[i]);
+				model->degree = atof(argv[i]);
 				break;
 			case 'e':
 				model->epsilon = atof(argv[i]);
@@ -305,7 +302,7 @@ void parse_command_line(int argc, char **argv, struct GenModel *model,
 					exit_invalid_param("epsilon", argv);
 				break;
 			case 'g':
-				gamma = atof(argv[i]);
+				model->gamma = atof(argv[i]);
 				break;
 			case 'k':
 				model->kappa = atof(argv[i]);
@@ -369,24 +366,4 @@ void parse_command_line(int argc, char **argv, struct GenModel *model,
 		(*testing_inputfile) = Malloc(char, strlen(argv[i])+1);
 		strcpy((*testing_inputfile), argv[i+1]);
 	}
-
-	// set kernel parameters
-	switch (model->kerneltype) {
-		case K_LINEAR:
-			break;
-		case K_POLY:
-			model->kernelparam = Calloc(double, 3);
-			model->kernelparam[0] = gamma;
-			model->kernelparam[1] = coef;
-			model->kernelparam[2] = degree;
-			break;
-		case K_RBF:
-			model->kernelparam = Calloc(double, 1);
-			model->kernelparam[0] = gamma;
-			break;
-		case K_SIGMOID:
-			model->kernelparam = Calloc(double, 1);
-			model->kernelparam[0] = gamma;
-			model->kernelparam[1] = coef;
-	}
 }
diff --git a/src/gensvm_base.c b/src/gensvm_base.c
index 6b979fd..79e5f45 100644
--- a/src/gensvm_base.c
+++ b/src/gensvm_base.c
@@ -53,7 +53,9 @@ struct GenData *gensvm_init_data()
 
 	// set default values
 	data->kerneltype = K_LINEAR;
-	data->kernelparam = NULL;
+	data->gamma = -1;
+	data->coef = -1;
+	data->degree = -1;
 
 	return data;
 }
@@ -82,7 +84,6 @@ void gensvm_free_data(struct GenData *data)
 		free(data->Z);
 		free(data->RAW);
 	}
-	free(data->kernelparam);
 	free(data->y);
 	free(data->Sigma);
 	free(data);
@@ -108,8 +109,10 @@ struct GenModel *gensvm_init_model()
 	model->epsilon = 1e-6;
 	model->kappa = 0.0;
 	model->weight_idx = 1;
+	model->gamma = 1.0;
+	model->coef = 0.0;
+	model->degree = 2.0;
 	model->kerneltype = K_LINEAR;
-	model->kernelparam = NULL;
 	model->kernel_eigen_cutoff = 1e-8;
 
 	model->V = NULL;
@@ -213,7 +216,6 @@ void gensvm_free_model(struct GenModel *model)
 	free(model->Q);
 	free(model->H);
 	free(model->rho);
-	free(model->kernelparam);
 	free(model->data_file);
 
 	free(model);
diff --git a/src/gensvm_consistency.c b/src/gensvm_consistency.c
index bf8cf9a..07ff7a6 100644
--- a/src/gensvm_consistency.c
+++ b/src/gensvm_consistency.c
@@ -256,8 +256,6 @@ void gensvm_consistency_repeats(struct GenQueue *q, long repeats,
 	}
 
 	free(cv_idx);
-	// make sure no double free occurs with the copied kernelparam
-	model->kernelparam = NULL;
 	gensvm_free_model(model);
 	gensvm_free_queue(nq);
 
diff --git a/src/gensvm_copy.c b/src/gensvm_copy.c
index 43a1107..28642c7 100644
--- a/src/gensvm_copy.c
+++ b/src/gensvm_copy.c
@@ -45,26 +45,7 @@ void gensvm_copy_model(struct GenModel *from, struct GenModel *to)
 	to->lambda = from->lambda;
 
 	to->kerneltype = from->kerneltype;
-	switch (to->kerneltype) {
-		case K_LINEAR:
-			break;
-		case K_POLY:
-			if (to->kernelparam) free(to->kernelparam);
-			to->kernelparam = Malloc(double, 3);
-			to->kernelparam[0] = from->kernelparam[0];
-			to->kernelparam[1] = from->kernelparam[1];
-			to->kernelparam[2] = from->kernelparam[2];
-			break;
-		case K_RBF:
-			if (to->kernelparam) free(to->kernelparam);
-			to->kernelparam = Malloc(double, 1);
-			to->kernelparam[0] = from->kernelparam[0];
-			break;
-		case K_SIGMOID:
-			if (to->kernelparam) free(to->kernelparam);
-			to->kernelparam = Malloc(double, 2);
-			to->kernelparam[0] = from->kernelparam[0];
-			to->kernelparam[1] = from->kernelparam[1];
-			break;
-	}
+	to->gamma = from->gamma;
+	to->coef = from->coef;
+	to->degree = from->degree;
 }
diff --git a/src/gensvm_gridsearch.c b/src/gensvm_gridsearch.c
index 387ebc1..e6adf8b 100644
--- a/src/gensvm_gridsearch.c
+++ b/src/gensvm_gridsearch.c
@@ -80,8 +80,6 @@ void gensvm_fill_queue(struct GenGrid *grid, struct GenQueue *queue,
 		task->test_data = test_data;
 		task->folds = grid->folds;
 		task->kerneltype = grid->kerneltype;
-		task->kernelparam = Calloc(double, grid->Ng +
-				grid->Nc + grid->Nd);
 		queue->tasks[i] = task;
 	}
 
@@ -140,8 +138,7 @@ void gensvm_fill_queue(struct GenGrid *grid, struct GenQueue *queue,
 	while (i < N) {
 		for (j=0; j<grid->Ne; j++) {
 			for (k=0; k<cnt; k++) {
-				queue->tasks[i]->epsilon =
-					grid->epsilons[j];
+				queue->tasks[i]->epsilon = grid->epsilons[j];
 				i++;
 			}
 		}
@@ -152,8 +149,7 @@ void gensvm_fill_queue(struct GenGrid *grid, struct GenQueue *queue,
 	while (i < N && grid->Ng > 0) {
 		for (j=0; j<grid->Ng; j++) {
 			for (k=0; k<cnt; k++) {
-				queue->tasks[i]->kernelparam[0] =
-					grid->gammas[j];
+				queue->tasks[i]->gamma = grid->gammas[j];
 				i++;
 			}
 		}
@@ -164,8 +160,7 @@ void gensvm_fill_queue(struct GenGrid *grid, struct GenQueue *queue,
 	while (i < N && grid->Nc > 0) {
 		for (j=0; j<grid->Nc; j++) {
 			for (k=0; k<cnt; k++) {
-				queue->tasks[i]->kernelparam[1] =
-					grid->coefs[j];
+				queue->tasks[i]->coef = grid->coefs[j];
 				i++;
 			}
 		}
@@ -176,8 +171,7 @@ void gensvm_fill_queue(struct GenGrid *grid, struct GenQueue *queue,
 	while (i < N && grid->Nd > 0) {
 		for (j=0; j<grid->Nd; j++) {
 			for (k=0; k<cnt; k++) {
-				queue->tasks[i]->kernelparam[2] =
-					grid->degrees[j];
+				queue->tasks[i]->degree = grid->degrees[j];
 				i++;
 			}
 		}
@@ -200,24 +194,27 @@ void gensvm_fill_queue(struct GenGrid *grid, struct GenQueue *queue,
  */
 bool gensvm_kernel_changed(struct GenTask *newtask, struct GenTask *oldtask)
 {
-	int i;
 	if (oldtask == NULL)
 		return true;
 	if (newtask->kerneltype != oldtask->kerneltype) {
 		return true;
 	} else if (newtask->kerneltype == K_POLY) {
-		for (i=0; i<3; i++)
-			if (newtask->kernelparam[i] != oldtask->kernelparam[i])
-				return true;
+		if (newtask->gamma != oldtask->gamma)
+			return true;
+		if (newtask->coef != oldtask->coef)
+			return true;
+		if (newtask->degree != oldtask->degree)
+			return true;
 		return false;
 	} else if (newtask->kerneltype == K_RBF) {
-		if (newtask->kernelparam[0] != oldtask->kernelparam[0])
+		if (newtask->gamma != oldtask->gamma)
 			return true;
 		return false;
 	} else if (newtask->kerneltype == K_SIGMOID) {
-		for (i=0; i<2; i++)
-			if (newtask->kernelparam[i] != oldtask->kernelparam[i])
-				return true;
+		if (newtask->gamma != oldtask->gamma)
+			return true;
+		if (newtask->coef != oldtask->coef)
+			return true;
 		return false;
 	}
 	return false;
@@ -331,8 +328,6 @@ void gensvm_train_queue(struct GenQueue *q)
 	note("\nTotal elapsed training time: %8.8f seconds\n",
 			gensvm_elapsed_time(&main_s, &main_e));
 
-	// make sure no double free occurs with the copied kernelparam
-	model->kernelparam = NULL;
 	gensvm_free_model(model);
 	for (f=0; f<folds; f++) {
 		gensvm_free_data(train_folds[f]);
@@ -365,15 +360,12 @@ void gensvm_gridsearch_progress(struct GenTask *task, long N, double perf,
 	char buffer[GENSVM_MAX_LINE_LENGTH];
 	sprintf(buffer, "(%03li/%03li)\t", task->ID+1, N);
 	if (task->kerneltype == K_POLY)
-		sprintf(buffer + strlen(buffer), "d = %2.2f\t",
-				task->kernelparam[2]);
+		sprintf(buffer + strlen(buffer), "d = %2.2f\t", task->degree);
 	if (task->kerneltype == K_POLY || task->kerneltype == K_SIGMOID)
-		sprintf(buffer + strlen(buffer), "c = %2.2f\t",
-				task->kernelparam[1]);
+		sprintf(buffer + strlen(buffer), "c = %2.2f\t", task->coef);
 	if (task->kerneltype == K_POLY || task->kerneltype == K_SIGMOID ||
 			task->kerneltype == K_RBF)
-		sprintf(buffer + strlen(buffer), "g = %3.3f\t",
-				task->kernelparam[0]);
+		sprintf(buffer + strlen(buffer), "g = %3.3f\t", task->gamma);
 	sprintf(buffer + strlen(buffer), "eps = %g\tw = %i\tk = %2.2f\t"
 			"l = %f\tp = %2.2f\t", task->epsilon,
 			task->weight_idx, task->kappa, task->lambda, task->p);
diff --git a/src/gensvm_kernel.c b/src/gensvm_kernel.c
index 8f0b6da..a25fcfd 100644
--- a/src/gensvm_kernel.c
+++ b/src/gensvm_kernel.c
@@ -46,29 +46,10 @@
 void gensvm_kernel_copy_kernelparam_to_data(struct GenModel *model, 
 		struct GenData *data)
 {
-	int i;
 	data->kerneltype = model->kerneltype;
-
-	free(data->kernelparam);
-	data->kernelparam = NULL;
-
-	switch (model->kerneltype) {
-		case K_LINEAR:
-			break;
-		case K_POLY:
-			data->kernelparam = Calloc(double, 3);
-			for (i=0; i<3; i++)
-				data->kernelparam[i] = model->kernelparam[i];
-			break;
-		case K_RBF:
-			data->kernelparam = Calloc(double, 1);
-			data->kernelparam[0] = model->kernelparam[0];
-			break;
-		case K_SIGMOID:
-			data->kernelparam = Calloc(double, 2);
-			data->kernelparam[0] = model->kernelparam[0];
-			data->kernelparam[1] = model->kernelparam[1];
-	}
+	data->gamma = model->gamma;
+	data->coef = model->coef;
+	data->degree = model->degree;
 }
 
 
@@ -188,14 +169,16 @@ void gensvm_kernel_compute(struct GenModel *model, struct GenData *data,
 			x1 = &data->RAW[i*(data->m+1)+1];
 			x2 = &data->RAW[j*(data->m+1)+1];
 			if (model->kerneltype == K_POLY)
-				value = gensvm_kernel_dot_poly(x1, x2,
-						model->kernelparam, data->m);
+				value = gensvm_kernel_dot_poly(x1, x2, data->m,
+						model->gamma, model->coef, 
+						model->degree);
 			else if (model->kerneltype == K_RBF)
-				value = gensvm_kernel_dot_rbf(x1, x2,
-						model->kernelparam, data->m);
+				value = gensvm_kernel_dot_rbf(x1, x2, data->m,
+						model-> gamma);
 			else if (model->kerneltype == K_SIGMOID)
-				value = gensvm_kernel_dot_sigmoid(x1, x2,
-						model->kernelparam, data->m);
+				value = gensvm_kernel_dot_sigmoid(x1, x2, 
+						data->m, model->gamma, 
+						model->coef);
 			else {
 				// LCOV_EXCL_START
 				err("[GenSVM Error]: Unknown kernel type in "
@@ -342,14 +325,15 @@ double *gensvm_kernel_cross(struct GenModel *model, struct GenData *data_train,
 			x1 = &data_test->RAW[i*(m+1)+1];
 			x2 = &data_train->RAW[j*(m+1)+1];
 			if (model->kerneltype == K_POLY)
-				value = gensvm_kernel_dot_poly(x1, x2,
-						model->kernelparam, m);
+				value = gensvm_kernel_dot_poly(x1, x2, m, 
+						model->gamma, model->coef, 
+						model->degree);
 			else if (model->kerneltype == K_RBF)
-				value = gensvm_kernel_dot_rbf(x1, x2,
-						model->kernelparam, m);
+				value = gensvm_kernel_dot_rbf(x1, x2, m, 
+						model->gamma);
 			else if (model->kerneltype == K_SIGMOID)
-				value = gensvm_kernel_dot_sigmoid(x1, x2,
-						model->kernelparam, m);
+				value = gensvm_kernel_dot_sigmoid(x1, x2, m,
+						model->gamma, model->coef);
 			else {
 				// LCOV_EXCL_START
 				err("[GenSVM Error]: Unknown kernel type in "
@@ -482,20 +466,18 @@ void gensvm_kernel_testfactor(struct GenData *testdata,
  *
  * @param[in] 	x1 		first vector
  * @param[in] 	x2 		second vector
- * @param[in] 	kernelparam 	array of kernel parameters (gamma is first
- * 				element)
  * @param[in] 	n 		length of the vectors x1 and x2
+ * @param[in] 	gamma 		gamma parameter of the kernel
  * @returns  			kernel evaluation
  */
-double gensvm_kernel_dot_rbf(double *x1, double *x2, double *kernelparam,
-		long n)
+double gensvm_kernel_dot_rbf(double *x1, double *x2, long n, double gamma)
 {
 	long i;
 	double value = 0.0;
 
 	for (i=0; i<n; i++)
 		value += (x1[i] - x2[i]) * (x1[i] - x2[i]);
-	value *= -kernelparam[0];
+	value *= -gamma;
 	return exp(value);
 }
 
@@ -506,23 +488,26 @@ double gensvm_kernel_dot_rbf(double *x1, double *x2, double *kernelparam,
  * The polynomial kernel is computed between two vectors. This kernel is
  * defined as
  * @f[
- * 	k(x_1, x_2) = ( \gamma \langle x_1, x_2 \rangle + c)^d
+ * 	k(x_1, x_2) = ( \gamma \langle x_1, x_2 \rangle + coef)^{degree}
  * @f]
- * where @f$ \gamma @f$, @f$ c @f$ and @f$ d @f$ are kernel parameters.
+ * where @f$ \gamma @f$, @f$ coef @f$ and @f$ degree @f$ are kernel 
+ * parameters.
  *
  * @param[in] 	x1 		first vector
  * @param[in] 	x2 		second vector
- * @param[in] 	kernelparam 	array of kernel parameters (gamma, c, d)
  * @param[in] 	n 		length of the vectors x1 and x2
+ * @param[in] 	gamma 		gamma parameter of the kernel
+ * @param[in] 	coef 		coef parameter of the kernel
+ * @param[in] 	degree 		degree parameter of the kernel
  * @returns 			kernel evaluation
  */
-double gensvm_kernel_dot_poly(double *x1, double *x2, double *kernelparam,
-		long n)
+double gensvm_kernel_dot_poly(double *x1, double *x2, long n, double gamma,
+		double coef, double degree)
 {
 	double value = cblas_ddot(n, x1, 1, x2, 1);
-	value *= kernelparam[0];
-	value += kernelparam[1];
-	return pow(value, kernelparam[2]);
+	value *= gamma;
+	value += coef;
+	return pow(value, degree);
 }
 
 /**
@@ -532,22 +517,23 @@ double gensvm_kernel_dot_poly(double *x1, double *x2, double *kernelparam,
  * The sigmoid kernel is computed between two vectors. This kernel is defined
  * as
  * @f[
- * 	k(x_1, x_2) = \tanh( \gamma \langle x_1 , x_2 \rangle + c)
+ * 	k(x_1, x_2) = \tanh( \gamma \langle x_1 , x_2 \rangle + coef)
  * @f]
- * where @f$ \gamma @f$ and @f$ c @f$ are kernel parameters.
+ * where @f$ \gamma @f$ and @f$ coef @f$ are kernel parameters.
  *
  * @param[in] 	x1 		first vector
  * @param[in] 	x2 		second vector
- * @param[in] 	kernelparam 	array of kernel parameters (gamma, c)
  * @param[in] 	n 		length of the vectors x1 and x2
+ * @param[in] 	gamma 		gamma parameter of the kernel
+ * @param[in] 	coef 		coef parameter of the kernel
  * @returns 			kernel evaluation
  */
-double gensvm_kernel_dot_sigmoid(double *x1, double *x2, double *kernelparam,
-		long n)
+double gensvm_kernel_dot_sigmoid(double *x1, double *x2, long n, double gamma,
+		double coef)
 {
 	double value = cblas_ddot(n, x1, 1, x2, 1);
-	value *= kernelparam[0];
-	value += kernelparam[1];
+	value *= gamma;
+	value += coef;
 	return tanh(value);
 }
 
diff --git a/src/gensvm_task.c b/src/gensvm_task.c
index 468705a..1526936 100644
--- a/src/gensvm_task.c
+++ b/src/gensvm_task.c
@@ -47,7 +47,9 @@ struct GenTask *gensvm_init_task()
 	t->kappa = 0.0;
 	t->lambda = 1.0;
 	t->epsilon = 1e-6;
-	t->kernelparam = NULL;
+	t->gamma = 1.0;
+	t->coef = 0.0;
+	t->degree = 2.0;
 	t->train_data = NULL;
 	t->test_data = NULL;
 	t->performance = 0.0;
@@ -59,16 +61,14 @@ struct GenTask *gensvm_init_task()
  * @brief Free the GenTask struct
  *
  * @details
- * Freeing the allocated memory of the GenTask means freeing _only_ the 
- * kernelparam array, and the task itself. The datasets are not freed, as 
- * these are shared between all tasks.
+ * Freeing the allocated memory of the GenTask means freeing _only_ the task 
+ * itself. The datasets are not freed, as these are shared between all tasks.
  *
  * @param[in] 	t 	GenTask to be freed
  *
  */
 void gensvm_free_task(struct GenTask *t)
 {
-	free(t->kernelparam);
 	free(t);
 	t = NULL;
 }
@@ -77,9 +77,8 @@ void gensvm_free_task(struct GenTask *t)
  * @brief Deepcopy a GenTask struct
  *
  * @details
- * Create a deep copy of a GenTask struct. The kernelparameters are copied to 
- * a new array. Note that the datasets belonging to the tasks are not copied, 
- * only the pointers to the datasets.
+ * Create a deep copy of a GenTask struct. Note that the datasets belonging to 
+ * the tasks are not copied, only the pointers to the datasets.
  *
  * @param[in] 	t 	input GenTask struct to copy
  *
@@ -100,21 +99,9 @@ struct GenTask *gensvm_copy_task(struct GenTask *t)
 	nt->performance = t->performance;
 
 	nt->kerneltype = t->kerneltype;
-	if (nt->kerneltype == K_LINEAR) {
-		nt->kernelparam = NULL;
-	} else if (nt->kerneltype == K_RBF) {
-		nt->kernelparam = Malloc(double, 1);
-		nt->kernelparam[0] = t->kernelparam[0];
-	} else if (nt->kerneltype == K_POLY) {
-		nt->kernelparam = Malloc(double, 3);
-		nt->kernelparam[0] = t->kernelparam[0];
-		nt->kernelparam[1] = t->kernelparam[1];
-		nt->kernelparam[2] = t->kernelparam[2];
-	} else if (nt->kerneltype == K_SIGMOID) {
-		nt->kernelparam = Malloc(double, 2);
-		nt->kernelparam[0] = t->kernelparam[0];
-		nt->kernelparam[1] = t->kernelparam[1];
-	}
+	nt->gamma = t->gamma;
+	nt->coef = t->coef;
+	nt->degree = t->degree;
 
 	return nt;
 }
@@ -140,19 +127,7 @@ void gensvm_task_to_model(struct GenTask *task, struct GenModel *model)
 
 	// copy kernel parameters
 	model->kerneltype = task->kerneltype;
-	if (model->kerneltype == K_LINEAR) {
-		model->kernelparam = NULL;
-	} else if (model->kerneltype == K_RBF) {
-		model->kernelparam = Malloc(double, 1);
-		model->kernelparam[0] = task->kernelparam[0];
-	} else if (model->kerneltype == K_POLY) {
-		model->kernelparam = Malloc(double, 3);
-		model->kernelparam[0] = task->kernelparam[0];
-		model->kernelparam[1] = task->kernelparam[1];
-		model->kernelparam[2] = task->kernelparam[2];
-	} else if (model->kerneltype == K_SIGMOID) {
-		model->kernelparam = Malloc(double, 2);
-		model->kernelparam[0] = task->kernelparam[0];
-		model->kernelparam[1] = task->kernelparam[1];
-	}
+	model->gamma = task->gamma;
+	model->coef = task->coef;
+	model->degree = task->degree;
 }
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;