GenSVM
test_gensvm_kernel.c
Go to the documentation of this file.
1 
27 #include "minunit.h"
28 #include "gensvm_kernel.h"
29 
30 char *test_kernel_copy_kernelparam_to_data_linear()
31 {
32  struct GenModel *model = gensvm_init_model();
33  struct GenData *data = gensvm_init_data();
34 
35  model->kerneltype = K_LINEAR;
36  data->kerneltype = K_RBF;
37 
38  // start test code //
39  gensvm_kernel_copy_kernelparam_to_data(model, data);
40 
41  mu_assert(data->kerneltype == K_LINEAR, "Incorrect data kerneltype");
42  // end test code //
43 
44  gensvm_free_data(data);
45  gensvm_free_model(model);
46 
47  return NULL;
48 }
49 
50 char *test_kernel_copy_kernelparam_to_data_rbf()
51 {
52  struct GenModel *model = gensvm_init_model();
53  struct GenData *data = gensvm_init_data();
54 
55  model->kerneltype = K_RBF;
56  model->gamma = 1.23;
57 
58  // start test code //
59  gensvm_kernel_copy_kernelparam_to_data(model, data);
60  mu_assert(data->kerneltype == K_RBF, "Incorrect data->kerneltype");
61  mu_assert(data->gamma == 1.23, "Incorrect data->gamma");
62 
63  // end test code //
64 
65  gensvm_free_data(data);
66  gensvm_free_model(model);
67 
68  return NULL;
69 }
70 
71 char *test_kernel_copy_kernelparam_to_data_poly()
72 {
73  struct GenModel *model = gensvm_init_model();
74  struct GenData *data = gensvm_init_data();
75 
76  model->kerneltype = K_POLY;
77  model->gamma = 1.23;
78  model->coef = 2.23;
79  model->degree = 3.23;
80 
81  // start test code //
82  gensvm_kernel_copy_kernelparam_to_data(model, data);
83  mu_assert(data->kerneltype == K_POLY, "Incorrect data->kerneltype");
84  mu_assert(data->gamma == 1.23, "Incorrect data->gamma");
85  mu_assert(data->coef == 2.23, "Incorrect data->coef");
86  mu_assert(data->degree == 3.23, "Incorrect data->degree");
87 
88  // end test code //
89 
90  gensvm_free_data(data);
91  gensvm_free_model(model);
92 
93  return NULL;
94 }
95 
96 char *test_kernel_copy_kernelparam_to_data_sigmoid()
97 {
98  struct GenModel *model = gensvm_init_model();
99  struct GenData *data = gensvm_init_data();
100 
101  model->kerneltype = K_SIGMOID;
102  model->gamma = 1.23;
103  model->coef = 2.23;
104 
105  // start test code //
106  gensvm_kernel_copy_kernelparam_to_data(model, data);
107  mu_assert(data->kerneltype == K_SIGMOID, "Incorrect data->kerneltype");
108  mu_assert(data->gamma == 1.23, "Incorrect data->gamma");
109  mu_assert(data->coef == 2.23, "Incorrect data->coef");
110 
111  // end test code //
112 
113  gensvm_free_data(data);
114  gensvm_free_model(model);
115 
116  return NULL;
117 }
118 
119 char *test_dot_rbf()
120 {
121  double dot, gamma;
122  double *a = Malloc(double, 5);
123  double *b = Malloc(double, 5);
124 
125  a[0] = 0.5203363837176203;
126  a[1] = 0.3860628599460129;
127  a[2] = 0.3592536954640216;
128  a[3] = 0.6824659760765744;
129  a[4] = 0.5390520090020700;
130 
131  b[0] = 0.1782643262351465;
132  b[1] = 0.0314270210724957;
133  b[2] = 0.5887219369641497;
134  b[3] = 0.7710042954911620;
135  b[4] = 0.8805451245738238;
136 
137  // start test code //
138  gamma = 1.0;
139  dot = gensvm_kernel_dot_rbf(a, b, 5, gamma);
140  mu_assert(fabs(dot - 0.657117701533133) < 1e-14, "Incorrect dot (1)");
141 
142  gamma = 5.0;
143  dot = gensvm_kernel_dot_rbf(a, b, 5, gamma);
144  mu_assert(fabs(dot - 0.122522495044048) < 1e-14, "Incorrect dot (2)");
145 
146  // end test code //
147  free(a);
148  free(b);
149 
150  return NULL;
151 }
152 
153 char *test_dot_poly()
154 {
155  double dot, gamma, coef, degree;
156  double *a = Malloc(double, 5);
157  double *b = Malloc(double, 5);
158 
159  a[0] = 0.5203363837176203;
160  a[1] = 0.3860628599460129;
161  a[2] = 0.3592536954640216;
162  a[3] = 0.6824659760765744;
163  a[4] = 0.5390520090020700;
164 
165  b[0] = 0.1782643262351465;
166  b[1] = 0.0314270210724957;
167  b[2] = 0.5887219369641497;
168  b[3] = 0.7710042954911620;
169  b[4] = 0.8805451245738238;
170 
171  // start test code //
172  gamma = 1.0;
173  coef = 1.0;
174  degree = 1.0;
175  dot = gensvm_kernel_dot_poly(a, b, 5, gamma, coef, degree);
176  mu_assert(fabs(dot - 2.31723456944910) < 1e-14, "Incorrect dot (1)");
177 
178  gamma = 1.5;
179  coef = 2.5;
180  degree = 3.5;
181  dot = gensvm_kernel_dot_poly(a, b, 5, gamma, coef, degree);
182  mu_assert(fabs(dot - 189.6989652572890179) < 1e-14, "Incorrect dot (2)");
183 
184  // end test code //
185  free(a);
186  free(b);
187  return NULL;
188 }
189 
190 char *test_dot_sigmoid()
191 {
192  double dot, gamma, coef;
193  double *a = Malloc(double, 5);
194  double *b = Malloc(double, 5);
195 
196  a[0] = 0.5203363837176203;
197  a[1] = 0.3860628599460129;
198  a[2] = 0.3592536954640216;
199  a[3] = 0.6824659760765744;
200  a[4] = 0.5390520090020700;
201 
202  b[0] = 0.1782643262351465;
203  b[1] = 0.0314270210724957;
204  b[2] = 0.5887219369641497;
205  b[3] = 0.7710042954911620;
206  b[4] = 0.8805451245738238;
207 
208  // start test code //
209  gamma = 1.0;
210  coef = 1.0;
211  dot = gensvm_kernel_dot_sigmoid(a, b, 5, gamma, coef);
212  mu_assert(fabs(dot - 0.9807642810850747) < 1e-14, "Incorrect dot (1)");
213 
214  gamma = 1.5;
215  coef = 2.5;
216  dot = gensvm_kernel_dot_sigmoid(a, b, 5, gamma, coef);
217  mu_assert(fabs(dot - 0.9997410009167159) < 1e-14, "Incorrect dot (2)");
218 
219  // end test code //
220  free(a);
221  free(b);
222 
223  return NULL;
224 }
225 
226 
227 char *test_kernel_preprocess_linear()
228 {
229  struct GenModel *model = gensvm_init_model();
230  struct GenData *data = gensvm_init_data();
231  model->kerneltype = K_LINEAR;
232  data->m = 10;
233  data->r = 0;
234 
235  gensvm_kernel_preprocess(model, data);
236 
237  mu_assert(data->r == 10, "Incorrect GenData::r");
238 
239  gensvm_free_model(model);
240  gensvm_free_data(data);
241 
242  return NULL;
243 }
244 
245 char *test_kernel_preprocess_kernel()
246 {
247  struct GenModel *model = gensvm_init_model();
248  struct GenData *data = gensvm_init_data();
249 
250  model->n = 10;
251  model->m = 5;
252  data->n = 10;
253  data->m = 5;
254 
255  model->kerneltype = K_RBF;
256  model->gamma = 0.348;
257  model->kernel_eigen_cutoff = 5e-3;
258 
259  data->Z = Calloc(double, data->n * (data->m + 1));
260  data->RAW = data->Z;
261  data->Sigma = Calloc(double, 10);
262 
263  matrix_set(data->Z, data->m+1, 0, 0, 1.0000000000000000);
264  matrix_set(data->Z, data->m+1, 0, 1, 0.8056271362589000);
265  matrix_set(data->Z, data->m+1, 0, 2, 0.4874175854113872);
266  matrix_set(data->Z, data->m+1, 0, 3, 0.4453015882771756);
267  matrix_set(data->Z, data->m+1, 0, 4, 0.8233234072519983);
268  matrix_set(data->Z, data->m+1, 0, 5, 0.2728942849022845);
269  matrix_set(data->Z, data->m+1, 1, 0, 1.0000000000000000);
270  matrix_set(data->Z, data->m+1, 1, 1, 0.7940590105180981);
271  matrix_set(data->Z, data->m+1, 1, 2, 0.1861049005485224);
272  matrix_set(data->Z, data->m+1, 1, 3, 0.8469394287449229);
273  matrix_set(data->Z, data->m+1, 1, 4, 0.7956168453294307);
274  matrix_set(data->Z, data->m+1, 1, 5, 0.2665038412777220);
275  matrix_set(data->Z, data->m+1, 2, 0, 1.0000000000000000);
276  matrix_set(data->Z, data->m+1, 2, 1, 0.0294257611061681);
277  matrix_set(data->Z, data->m+1, 2, 2, 0.0242717976065267);
278  matrix_set(data->Z, data->m+1, 2, 3, 0.5039128672814752);
279  matrix_set(data->Z, data->m+1, 2, 4, 0.5777227081256917);
280  matrix_set(data->Z, data->m+1, 2, 5, 0.1126634767453339);
281  matrix_set(data->Z, data->m+1, 3, 0, 1.0000000000000000);
282  matrix_set(data->Z, data->m+1, 3, 1, 0.1746563833537603);
283  matrix_set(data->Z, data->m+1, 3, 2, 0.9135736087631979);
284  matrix_set(data->Z, data->m+1, 3, 3, 0.5270258081021366);
285  matrix_set(data->Z, data->m+1, 3, 4, 0.4426030703804438);
286  matrix_set(data->Z, data->m+1, 3, 5, 0.9577384085295405);
287  matrix_set(data->Z, data->m+1, 4, 0, 1.0000000000000000);
288  matrix_set(data->Z, data->m+1, 4, 1, 0.0022298761599785);
289  matrix_set(data->Z, data->m+1, 4, 2, 0.3773482059713607);
290  matrix_set(data->Z, data->m+1, 4, 3, 0.8009654729622842);
291  matrix_set(data->Z, data->m+1, 4, 4, 0.7701104553132680);
292  matrix_set(data->Z, data->m+1, 4, 5, 0.4421972387164297);
293  matrix_set(data->Z, data->m+1, 5, 0, 1.0000000000000000);
294  matrix_set(data->Z, data->m+1, 5, 1, 0.6638830667081945);
295  matrix_set(data->Z, data->m+1, 5, 2, 0.6467607601353914);
296  matrix_set(data->Z, data->m+1, 5, 3, 0.0434948735457108);
297  matrix_set(data->Z, data->m+1, 5, 4, 0.3267543833513200);
298  matrix_set(data->Z, data->m+1, 5, 5, 0.3993579061297995);
299  matrix_set(data->Z, data->m+1, 6, 0, 1.0000000000000000);
300  matrix_set(data->Z, data->m+1, 6, 1, 0.0770493004546461);
301  matrix_set(data->Z, data->m+1, 6, 2, 0.3699566427075194);
302  matrix_set(data->Z, data->m+1, 6, 3, 0.7863539761080217);
303  matrix_set(data->Z, data->m+1, 6, 4, 0.3693175185473680);
304  matrix_set(data->Z, data->m+1, 6, 5, 0.9137371110726166);
305  matrix_set(data->Z, data->m+1, 7, 0, 1.0000000000000000);
306  matrix_set(data->Z, data->m+1, 7, 1, 0.2685233952731509);
307  matrix_set(data->Z, data->m+1, 7, 2, 0.8539966432782011);
308  matrix_set(data->Z, data->m+1, 7, 3, 0.0967159557826836);
309  matrix_set(data->Z, data->m+1, 7, 4, 0.2456426390463990);
310  matrix_set(data->Z, data->m+1, 7, 5, 0.0191704319054138);
311  matrix_set(data->Z, data->m+1, 8, 0, 1.0000000000000000);
312  matrix_set(data->Z, data->m+1, 8, 1, 0.1163951898554611);
313  matrix_set(data->Z, data->m+1, 8, 2, 0.7667861436369238);
314  matrix_set(data->Z, data->m+1, 8, 3, 0.5031912600213351);
315  matrix_set(data->Z, data->m+1, 8, 4, 0.1102697774064020);
316  matrix_set(data->Z, data->m+1, 8, 5, 0.4826593547737735);
317  matrix_set(data->Z, data->m+1, 9, 0, 1.0000000000000000);
318  matrix_set(data->Z, data->m+1, 9, 1, 0.2290251898688216);
319  matrix_set(data->Z, data->m+1, 9, 2, 0.4401981048538806);
320  matrix_set(data->Z, data->m+1, 9, 3, 0.0884616753393881);
321  matrix_set(data->Z, data->m+1, 9, 4, 0.8659836346403005);
322  matrix_set(data->Z, data->m+1, 9, 5, 0.1028774221216107);
323 
324  // start test code //
325  gensvm_kernel_preprocess(model, data);
326  mu_assert(data->r == 7, "Incorrect data->r");
327 
328  double eps = 1e-14;
329  mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 0, 0)) -
330  fabs(1.0000000000000000)) < eps,
331  "Incorrect data->Z at 0, 0");
332  mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 0, 1)) -
333  fabs(2.4632837902141640)) < eps,
334  "Incorrect data->Z at 0, 1");
335  mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 0, 2)) -
336  fabs(-0.3037489220604925)) < eps,
337  "Incorrect data->Z at 0, 2");
338  mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 0, 3)) -
339  fabs(-0.0061287029147240)) < eps,
340  "Incorrect data->Z at 0, 3");
341  mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 0, 4)) -
342  fabs(0.1822712619914593)) < eps,
343  "Incorrect data->Z at 0, 4");
344  mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 0, 5)) -
345  fabs(0.0252737053303148)) < eps,
346  "Incorrect data->Z at 0, 5");
347  mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 0, 6)) -
348  fabs(-0.0078753266252524)) < eps,
349  "Incorrect data->Z at 0, 6");
350  mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 0, 7)) -
351  fabs(-0.0012800124996018)) < eps,
352  "Incorrect data->Z at 0, 7");
353  mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 1, 0)) -
354  fabs(1.0000000000000000)) < eps,
355  "Incorrect data->Z at 1, 0");
356  mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 1, 1)) -
357  fabs(2.2923640983040641)) < eps,
358  "Incorrect data->Z at 1, 1");
359  mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 1, 2)) -
360  fabs(-0.3048037728463330)) < eps,
361  "Incorrect data->Z at 1, 2");
362  mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 1, 3)) -
363  fabs(-0.2586192720897897)) < eps,
364  "Incorrect data->Z at 1, 3");
365  mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 1, 4)) -
366  fabs(0.1747912247100736)) < eps,
367  "Incorrect data->Z at 1, 4");
368  mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 1, 5)) -
369  fabs(-0.0623497873850738)) < eps,
370  "Incorrect data->Z at 1, 5");
371  mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 1, 6)) -
372  fabs(-0.0199493291395259)) < eps,
373  "Incorrect data->Z at 1, 6");
374  mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 1, 7)) -
375  fabs(0.0068540206892510)) < eps,
376  "Incorrect data->Z at 1, 7");
377  mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 2, 0)) -
378  fabs(1.0000000000000000)) < eps,
379  "Incorrect data->Z at 2, 0");
380  mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 2, 1)) -
381  fabs(2.4167201742337761)) < eps,
382  "Incorrect data->Z at 2, 1");
383  mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 2, 2)) -
384  fabs(-0.1499385272847361)) < eps,
385  "Incorrect data->Z at 2, 2");
386  mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 2, 3)) -
387  fabs(-0.1781619658696836)) < eps,
388  "Incorrect data->Z at 2, 3");
389  mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 2, 4)) -
390  fabs(-0.2363293887681946)) < eps,
391  "Incorrect data->Z at 2, 4");
392  mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 2, 5)) -
393  fabs(-0.0362117307160720)) < eps,
394  "Incorrect data->Z at 2, 5");
395  mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 2, 6)) -
396  fabs(0.0366137533260933)) < eps,
397  "Incorrect data->Z at 2, 6");
398  mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 2, 7)) -
399  fabs(0.0227049982868101)) < eps,
400  "Incorrect data->Z at 2, 7");
401  mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 3, 0)) -
402  fabs(1.0000000000000000)) < eps,
403  "Incorrect data->Z at 3, 0");
404  mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 3, 1)) -
405  fabs(2.3339314848494390)) < eps,
406  "Incorrect data->Z at 3, 1");
407  mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 3, 2)) -
408  fabs(0.4067278927345656)) < eps,
409  "Incorrect data->Z at 3, 2");
410  mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 3, 3)) -
411  fabs(0.0198947146890620)) < eps,
412  "Incorrect data->Z at 3, 3");
413  mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 3, 4)) -
414  fabs(0.1187106614859180)) < eps,
415  "Incorrect data->Z at 3, 4");
416  mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 3, 5)) -
417  fabs(0.0734848412140159)) < eps,
418  "Incorrect data->Z at 3, 5");
419  mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 3, 6)) -
420  fabs(-0.0166955533210990)) < eps,
421  "Incorrect data->Z at 3, 6");
422  mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 3, 7)) -
423  fabs(0.0229112619510384)) < eps,
424  "Incorrect data->Z at 3, 7");
425  mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 4, 0)) -
426  fabs(1.0000000000000000)) < eps,
427  "Incorrect data->Z at 4, 0");
428  mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 4, 1)) -
429  fabs(2.5061509421266424)) < eps,
430  "Incorrect data->Z at 4, 1");
431  mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 4, 2)) -
432  fabs(0.0574469229922174)) < eps,
433  "Incorrect data->Z at 4, 2");
434  mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 4, 3)) -
435  fabs(-0.2858649955147738)) < eps,
436  "Incorrect data->Z at 4, 3");
437  mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 4, 4)) -
438  fabs(-0.0995031375002134)) < eps,
439  "Incorrect data->Z at 4, 4");
440  mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 4, 5)) -
441  fabs(0.0223790101651578)) < eps,
442  "Incorrect data->Z at 4, 5");
443  mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 4, 6)) -
444  fabs(-0.0355571480867735)) < eps,
445  "Incorrect data->Z at 4, 6");
446  mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 4, 7)) -
447  fabs(-0.0219026472149696)) < eps,
448  "Incorrect data->Z at 4, 7");
449  mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 5, 0)) -
450  fabs(1.0000000000000000)) < eps,
451  "Incorrect data->Z at 5, 0");
452  mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 5, 1)) -
453  fabs(2.4482858151168982)) < eps,
454  "Incorrect data->Z at 5, 1");
455  mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 5, 2)) -
456  fabs(-0.0670998214520230)) < eps,
457  "Incorrect data->Z at 5, 2");
458  mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 5, 3)) -
459  fabs(0.3147064295566219)) < eps,
460  "Incorrect data->Z at 5, 3");
461  mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 5, 4)) -
462  fabs(0.1070535630418465)) < eps,
463  "Incorrect data->Z at 5, 4");
464  mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 5, 5)) -
465  fabs(-0.0052824396955993)) < eps,
466  "Incorrect data->Z at 5, 5");
467  mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 5, 6)) -
468  fabs(0.0614363461130733)) < eps,
469  "Incorrect data->Z at 5, 6");
470  mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 5, 7)) -
471  fabs(-0.0075355247061472)) < eps,
472  "Incorrect data->Z at 5, 7");
473  mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 6, 0)) -
474  fabs(1.0000000000000000)) < eps,
475  "Incorrect data->Z at 6, 0");
476  mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 6, 1)) -
477  fabs(2.3638928644404329)) < eps,
478  "Incorrect data->Z at 6, 1");
479  mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 6, 2)) -
480  fabs(0.3482541374011597)) < eps,
481  "Incorrect data->Z at 6, 2");
482  mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 6, 3)) -
483  fabs(-0.2422541976251498)) < eps,
484  "Incorrect data->Z at 6, 3");
485  mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 6, 4)) -
486  fabs(0.0251886519764033)) < eps,
487  "Incorrect data->Z at 6, 4");
488  mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 6, 5)) -
489  fabs(-0.0079397861684362)) < eps,
490  "Incorrect data->Z at 6, 5");
491  mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 6, 6)) -
492  fabs(0.0424975213407462)) < eps,
493  "Incorrect data->Z at 6, 6");
494  mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 6, 7)) -
495  fabs(-0.0204279932276333)) < eps,
496  "Incorrect data->Z at 6, 7");
497  mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 7, 0)) -
498  fabs(1.0000000000000000)) < eps,
499  "Incorrect data->Z at 7, 0");
500  mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 7, 1)) -
501  fabs(2.3607306299135344)) < eps,
502  "Incorrect data->Z at 7, 1");
503  mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 7, 2)) -
504  fabs(-0.0220102589508912)) < eps,
505  "Incorrect data->Z at 7, 2");
506  mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 7, 3)) -
507  fabs(0.3913398731540265)) < eps,
508  "Incorrect data->Z at 7, 3");
509  mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 7, 4)) -
510  fabs(-0.0941469673695446)) < eps,
511  "Incorrect data->Z at 7, 4");
512  mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 7, 5)) -
513  fabs(-0.0477595489009114)) < eps,
514  "Incorrect data->Z at 7, 5");
515  mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 7, 6)) -
516  fabs(-0.0367688438245860)) < eps,
517  "Incorrect data->Z at 7, 6");
518  mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 7, 7)) -
519  fabs(-0.0133498576642393)) < eps,
520  "Incorrect data->Z at 7, 7");
521  mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 8, 0)) -
522  fabs(1.0000000000000000)) < eps,
523  "Incorrect data->Z at 8, 0");
524  mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 8, 1)) -
525  fabs(2.5023932475093376)) < eps,
526  "Incorrect data->Z at 8, 1");
527  mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 8, 2)) -
528  fabs(0.2929602950386334)) < eps,
529  "Incorrect data->Z at 8, 2");
530  mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 8, 3)) -
531  fabs(0.1371647327912284)) < eps,
532  "Incorrect data->Z at 8, 3");
533  mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 8, 4)) -
534  fabs(-0.0270505649533715)) < eps,
535  "Incorrect data->Z at 8, 4");
536  mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 8, 5)) -
537  fabs(-0.0685258491091892)) < eps,
538  "Incorrect data->Z at 8, 5");
539  mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 8, 6)) -
540  fabs(-0.0213385621647371)) < eps,
541  "Incorrect data->Z at 8, 6");
542  mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 8, 7)) -
543  fabs(0.0121305554343051)) < eps,
544  "Incorrect data->Z at 8, 7");
545  mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 9, 0)) -
546  fabs(1.0000000000000000)) < eps,
547  "Incorrect data->Z at 9, 0");
548  mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 9, 1)) -
549  fabs(2.4579608302226870)) < eps,
550  "Incorrect data->Z at 9, 1");
551  mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 9, 2)) -
552  fabs(-0.2538863526247282)) < eps,
553  "Incorrect data->Z at 9, 2");
554  mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 9, 3)) -
555  fabs(0.0991005899665861)) < eps,
556  "Incorrect data->Z at 9, 3");
557  mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 9, 4)) -
558  fabs(-0.1374781282330359)) < eps,
559  "Incorrect data->Z at 9, 4");
560  mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 9, 5)) -
561  fabs(0.1043628273525485)) < eps,
562  "Incorrect data->Z at 9, 5");
563  mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 9, 6)) -
564  fabs(-0.0024213407513349)) < eps,
565  "Incorrect data->Z at 9, 6");
566  mu_assert(fabs(fabs(matrix_get(data->Z, data->r+1, 9, 7)) -
567  fabs(0.0007673936590348)) < eps,
568  "Incorrect data->Z at 9, 7");
569 
570  mu_assert(fabs(matrix_get(data->RAW, data->m+1, 0, 0) -
571  1.0000000000000000) < eps,
572  "Incorrect data->RAW at 0, 0");
573  mu_assert(fabs(matrix_get(data->RAW, data->m+1, 0, 1) -
574  0.8056271362589000) < eps,
575  "Incorrect data->RAW at 0, 1");
576  mu_assert(fabs(matrix_get(data->RAW, data->m+1, 0, 2) -
577  0.4874175854113872) < eps,
578  "Incorrect data->RAW at 0, 2");
579  mu_assert(fabs(matrix_get(data->RAW, data->m+1, 0, 3) -
580  0.4453015882771756) < eps,
581  "Incorrect data->RAW at 0, 3");
582  mu_assert(fabs(matrix_get(data->RAW, data->m+1, 0, 4) -
583  0.8233234072519983) < eps,
584  "Incorrect data->RAW at 0, 4");
585  mu_assert(fabs(matrix_get(data->RAW, data->m+1, 0, 5) -
586  0.2728942849022845) < eps,
587  "Incorrect data->RAW at 0, 5");
588  mu_assert(fabs(matrix_get(data->RAW, data->m+1, 1, 0) -
589  1.0000000000000000) < eps,
590  "Incorrect data->RAW at 1, 0");
591  mu_assert(fabs(matrix_get(data->RAW, data->m+1, 1, 1) -
592  0.7940590105180981) < eps,
593  "Incorrect data->RAW at 1, 1");
594  mu_assert(fabs(matrix_get(data->RAW, data->m+1, 1, 2) -
595  0.1861049005485224) < eps,
596  "Incorrect data->RAW at 1, 2");
597  mu_assert(fabs(matrix_get(data->RAW, data->m+1, 1, 3) -
598  0.8469394287449229) < eps,
599  "Incorrect data->RAW at 1, 3");
600  mu_assert(fabs(matrix_get(data->RAW, data->m+1, 1, 4) -
601  0.7956168453294307) < eps,
602  "Incorrect data->RAW at 1, 4");
603  mu_assert(fabs(matrix_get(data->RAW, data->m+1, 1, 5) -
604  0.2665038412777220) < eps,
605  "Incorrect data->RAW at 1, 5");
606  mu_assert(fabs(matrix_get(data->RAW, data->m+1, 2, 0) -
607  1.0000000000000000) < eps,
608  "Incorrect data->RAW at 2, 0");
609  mu_assert(fabs(matrix_get(data->RAW, data->m+1, 2, 1) -
610  0.0294257611061681) < eps,
611  "Incorrect data->RAW at 2, 1");
612  mu_assert(fabs(matrix_get(data->RAW, data->m+1, 2, 2) -
613  0.0242717976065267) < eps,
614  "Incorrect data->RAW at 2, 2");
615  mu_assert(fabs(matrix_get(data->RAW, data->m+1, 2, 3) -
616  0.5039128672814752) < eps,
617  "Incorrect data->RAW at 2, 3");
618  mu_assert(fabs(matrix_get(data->RAW, data->m+1, 2, 4) -
619  0.5777227081256917) < eps,
620  "Incorrect data->RAW at 2, 4");
621  mu_assert(fabs(matrix_get(data->RAW, data->m+1, 2, 5) -
622  0.1126634767453339) < eps,
623  "Incorrect data->RAW at 2, 5");
624  mu_assert(fabs(matrix_get(data->RAW, data->m+1, 3, 0) -
625  1.0000000000000000) < eps,
626  "Incorrect data->RAW at 3, 0");
627  mu_assert(fabs(matrix_get(data->RAW, data->m+1, 3, 1) -
628  0.1746563833537603) < eps,
629  "Incorrect data->RAW at 3, 1");
630  mu_assert(fabs(matrix_get(data->RAW, data->m+1, 3, 2) -
631  0.9135736087631979) < eps,
632  "Incorrect data->RAW at 3, 2");
633  mu_assert(fabs(matrix_get(data->RAW, data->m+1, 3, 3) -
634  0.5270258081021366) < eps,
635  "Incorrect data->RAW at 3, 3");
636  mu_assert(fabs(matrix_get(data->RAW, data->m+1, 3, 4) -
637  0.4426030703804438) < eps,
638  "Incorrect data->RAW at 3, 4");
639  mu_assert(fabs(matrix_get(data->RAW, data->m+1, 3, 5) -
640  0.9577384085295405) < eps,
641  "Incorrect data->RAW at 3, 5");
642  mu_assert(fabs(matrix_get(data->RAW, data->m+1, 4, 0) -
643  1.0000000000000000) < eps,
644  "Incorrect data->RAW at 4, 0");
645  mu_assert(fabs(matrix_get(data->RAW, data->m+1, 4, 1) -
646  0.0022298761599785) < eps,
647  "Incorrect data->RAW at 4, 1");
648  mu_assert(fabs(matrix_get(data->RAW, data->m+1, 4, 2) -
649  0.3773482059713607) < eps,
650  "Incorrect data->RAW at 4, 2");
651  mu_assert(fabs(matrix_get(data->RAW, data->m+1, 4, 3) -
652  0.8009654729622842) < eps,
653  "Incorrect data->RAW at 4, 3");
654  mu_assert(fabs(matrix_get(data->RAW, data->m+1, 4, 4) -
655  0.7701104553132680) < eps,
656  "Incorrect data->RAW at 4, 4");
657  mu_assert(fabs(matrix_get(data->RAW, data->m+1, 4, 5) -
658  0.4421972387164297) < eps,
659  "Incorrect data->RAW at 4, 5");
660  mu_assert(fabs(matrix_get(data->RAW, data->m+1, 5, 0) -
661  1.0000000000000000) < eps,
662  "Incorrect data->RAW at 5, 0");
663  mu_assert(fabs(matrix_get(data->RAW, data->m+1, 5, 1) -
664  0.6638830667081945) < eps,
665  "Incorrect data->RAW at 5, 1");
666  mu_assert(fabs(matrix_get(data->RAW, data->m+1, 5, 2) -
667  0.6467607601353914) < eps,
668  "Incorrect data->RAW at 5, 2");
669  mu_assert(fabs(matrix_get(data->RAW, data->m+1, 5, 3) -
670  0.0434948735457108) < eps,
671  "Incorrect data->RAW at 5, 3");
672  mu_assert(fabs(matrix_get(data->RAW, data->m+1, 5, 4) -
673  0.3267543833513200) < eps,
674  "Incorrect data->RAW at 5, 4");
675  mu_assert(fabs(matrix_get(data->RAW, data->m+1, 5, 5) -
676  0.3993579061297995) < eps,
677  "Incorrect data->RAW at 5, 5");
678  mu_assert(fabs(matrix_get(data->RAW, data->m+1, 6, 0) -
679  1.0000000000000000) < eps,
680  "Incorrect data->RAW at 6, 0");
681  mu_assert(fabs(matrix_get(data->RAW, data->m+1, 6, 1) -
682  0.0770493004546461) < eps,
683  "Incorrect data->RAW at 6, 1");
684  mu_assert(fabs(matrix_get(data->RAW, data->m+1, 6, 2) -
685  0.3699566427075194) < eps,
686  "Incorrect data->RAW at 6, 2");
687  mu_assert(fabs(matrix_get(data->RAW, data->m+1, 6, 3) -
688  0.7863539761080217) < eps,
689  "Incorrect data->RAW at 6, 3");
690  mu_assert(fabs(matrix_get(data->RAW, data->m+1, 6, 4) -
691  0.3693175185473680) < eps,
692  "Incorrect data->RAW at 6, 4");
693  mu_assert(fabs(matrix_get(data->RAW, data->m+1, 6, 5) -
694  0.9137371110726166) < eps,
695  "Incorrect data->RAW at 6, 5");
696  mu_assert(fabs(matrix_get(data->RAW, data->m+1, 7, 0) -
697  1.0000000000000000) < eps,
698  "Incorrect data->RAW at 7, 0");
699  mu_assert(fabs(matrix_get(data->RAW, data->m+1, 7, 1) -
700  0.2685233952731509) < eps,
701  "Incorrect data->RAW at 7, 1");
702  mu_assert(fabs(matrix_get(data->RAW, data->m+1, 7, 2) -
703  0.8539966432782011) < eps,
704  "Incorrect data->RAW at 7, 2");
705  mu_assert(fabs(matrix_get(data->RAW, data->m+1, 7, 3) -
706  0.0967159557826836) < eps,
707  "Incorrect data->RAW at 7, 3");
708  mu_assert(fabs(matrix_get(data->RAW, data->m+1, 7, 4) -
709  0.2456426390463990) < eps,
710  "Incorrect data->RAW at 7, 4");
711  mu_assert(fabs(matrix_get(data->RAW, data->m+1, 7, 5) -
712  0.0191704319054138) < eps,
713  "Incorrect data->RAW at 7, 5");
714  mu_assert(fabs(matrix_get(data->RAW, data->m+1, 8, 0) -
715  1.0000000000000000) < eps,
716  "Incorrect data->RAW at 8, 0");
717  mu_assert(fabs(matrix_get(data->RAW, data->m+1, 8, 1) -
718  0.1163951898554611) < eps,
719  "Incorrect data->RAW at 8, 1");
720  mu_assert(fabs(matrix_get(data->RAW, data->m+1, 8, 2) -
721  0.7667861436369238) < eps,
722  "Incorrect data->RAW at 8, 2");
723  mu_assert(fabs(matrix_get(data->RAW, data->m+1, 8, 3) -
724  0.5031912600213351) < eps,
725  "Incorrect data->RAW at 8, 3");
726  mu_assert(fabs(matrix_get(data->RAW, data->m+1, 8, 4) -
727  0.1102697774064020) < eps,
728  "Incorrect data->RAW at 8, 4");
729  mu_assert(fabs(matrix_get(data->RAW, data->m+1, 8, 5) -
730  0.4826593547737735) < eps,
731  "Incorrect data->RAW at 8, 5");
732  mu_assert(fabs(matrix_get(data->RAW, data->m+1, 9, 0) -
733  1.0000000000000000) < eps,
734  "Incorrect data->RAW at 9, 0");
735  mu_assert(fabs(matrix_get(data->RAW, data->m+1, 9, 1) -
736  0.2290251898688216) < eps,
737  "Incorrect data->RAW at 9, 1");
738  mu_assert(fabs(matrix_get(data->RAW, data->m+1, 9, 2) -
739  0.4401981048538806) < eps,
740  "Incorrect data->RAW at 9, 2");
741  mu_assert(fabs(matrix_get(data->RAW, data->m+1, 9, 3) -
742  0.0884616753393881) < eps,
743  "Incorrect data->RAW at 9, 3");
744  mu_assert(fabs(matrix_get(data->RAW, data->m+1, 9, 4) -
745  0.8659836346403005) < eps,
746  "Incorrect data->RAW at 9, 4");
747  mu_assert(fabs(matrix_get(data->RAW, data->m+1, 9, 5) -
748  0.1028774221216107) < eps,
749  "Incorrect data->RAW at 9, 5");
750 
751  // end test code //
752 
753 
754 
755  gensvm_free_model(model);
756  gensvm_free_data(data);
757 
758  return NULL;
759 }
760 
761 
762 char *test_kernel_postprocess_linear()
763 {
764  struct GenModel *model = gensvm_init_model();
765  struct GenData *train = gensvm_init_data();
766  struct GenData *test = gensvm_init_data();
767 
768  model->kerneltype = K_LINEAR;
769  test->m = 10;
770  test->r = 0;
771 
772  // start test code //
773  gensvm_kernel_postprocess(model, train, test);
774 
775  mu_assert(test->r == 10, "Incorrect test->r");
776 
777  // end test code //
778 
779  gensvm_free_model(model);
780  gensvm_free_data(train);
781  gensvm_free_data(test);
782 
783  return NULL;
784 }
785 
786 char *test_kernel_postprocess_kernel()
787 {
788  struct GenModel *model = gensvm_init_model();
789  struct GenData *train = gensvm_init_data();
790  struct GenData *test = gensvm_init_data();
791 
792  train->n = 10;
793  train->m = 5;
794  train->r = train->m;
795  train->RAW = Calloc(double, train->n * (train->m + 1));
796  train->Sigma = Calloc(double, train->m);
797 
798  test->n = 8;
799  test->m = 5;
800  test->RAW = Calloc(double, test->n * (test->m + 1));
801 
802  model->kerneltype = K_RBF;
803  model->gamma = 1.132;
804 
805  // start test code //
806 
807  matrix_set(train->RAW, train->m+1, 0, 0, 1.0000000000000000);
808  matrix_set(train->RAW, train->m+1, 0, 1, 0.8056271362589000);
809  matrix_set(train->RAW, train->m+1, 0, 2, 0.4874175854113872);
810  matrix_set(train->RAW, train->m+1, 0, 3, 0.4453015882771756);
811  matrix_set(train->RAW, train->m+1, 0, 4, 0.8233234072519983);
812  matrix_set(train->RAW, train->m+1, 0, 5, 0.2728942849022845);
813  matrix_set(train->RAW, train->m+1, 1, 0, 1.0000000000000000);
814  matrix_set(train->RAW, train->m+1, 1, 1, 0.7940590105180981);
815  matrix_set(train->RAW, train->m+1, 1, 2, 0.1861049005485224);
816  matrix_set(train->RAW, train->m+1, 1, 3, 0.8469394287449229);
817  matrix_set(train->RAW, train->m+1, 1, 4, 0.7956168453294307);
818  matrix_set(train->RAW, train->m+1, 1, 5, 0.2665038412777220);
819  matrix_set(train->RAW, train->m+1, 2, 0, 1.0000000000000000);
820  matrix_set(train->RAW, train->m+1, 2, 1, 0.0294257611061681);
821  matrix_set(train->RAW, train->m+1, 2, 2, 0.0242717976065267);
822  matrix_set(train->RAW, train->m+1, 2, 3, 0.5039128672814752);
823  matrix_set(train->RAW, train->m+1, 2, 4, 0.5777227081256917);
824  matrix_set(train->RAW, train->m+1, 2, 5, 0.1126634767453339);
825  matrix_set(train->RAW, train->m+1, 3, 0, 1.0000000000000000);
826  matrix_set(train->RAW, train->m+1, 3, 1, 0.1746563833537603);
827  matrix_set(train->RAW, train->m+1, 3, 2, 0.9135736087631979);
828  matrix_set(train->RAW, train->m+1, 3, 3, 0.5270258081021366);
829  matrix_set(train->RAW, train->m+1, 3, 4, 0.4426030703804438);
830  matrix_set(train->RAW, train->m+1, 3, 5, 0.9577384085295405);
831  matrix_set(train->RAW, train->m+1, 4, 0, 1.0000000000000000);
832  matrix_set(train->RAW, train->m+1, 4, 1, 0.0022298761599785);
833  matrix_set(train->RAW, train->m+1, 4, 2, 0.3773482059713607);
834  matrix_set(train->RAW, train->m+1, 4, 3, 0.8009654729622842);
835  matrix_set(train->RAW, train->m+1, 4, 4, 0.7701104553132680);
836  matrix_set(train->RAW, train->m+1, 4, 5, 0.4421972387164297);
837  matrix_set(train->RAW, train->m+1, 5, 0, 1.0000000000000000);
838  matrix_set(train->RAW, train->m+1, 5, 1, 0.6638830667081945);
839  matrix_set(train->RAW, train->m+1, 5, 2, 0.6467607601353914);
840  matrix_set(train->RAW, train->m+1, 5, 3, 0.0434948735457108);
841  matrix_set(train->RAW, train->m+1, 5, 4, 0.3267543833513200);
842  matrix_set(train->RAW, train->m+1, 5, 5, 0.3993579061297995);
843  matrix_set(train->RAW, train->m+1, 6, 0, 1.0000000000000000);
844  matrix_set(train->RAW, train->m+1, 6, 1, 0.0770493004546461);
845  matrix_set(train->RAW, train->m+1, 6, 2, 0.3699566427075194);
846  matrix_set(train->RAW, train->m+1, 6, 3, 0.7863539761080217);
847  matrix_set(train->RAW, train->m+1, 6, 4, 0.3693175185473680);
848  matrix_set(train->RAW, train->m+1, 6, 5, 0.9137371110726166);
849  matrix_set(train->RAW, train->m+1, 7, 0, 1.0000000000000000);
850  matrix_set(train->RAW, train->m+1, 7, 1, 0.2685233952731509);
851  matrix_set(train->RAW, train->m+1, 7, 2, 0.8539966432782011);
852  matrix_set(train->RAW, train->m+1, 7, 3, 0.0967159557826836);
853  matrix_set(train->RAW, train->m+1, 7, 4, 0.2456426390463990);
854  matrix_set(train->RAW, train->m+1, 7, 5, 0.0191704319054138);
855  matrix_set(train->RAW, train->m+1, 8, 0, 1.0000000000000000);
856  matrix_set(train->RAW, train->m+1, 8, 1, 0.1163951898554611);
857  matrix_set(train->RAW, train->m+1, 8, 2, 0.7667861436369238);
858  matrix_set(train->RAW, train->m+1, 8, 3, 0.5031912600213351);
859  matrix_set(train->RAW, train->m+1, 8, 4, 0.1102697774064020);
860  matrix_set(train->RAW, train->m+1, 8, 5, 0.4826593547737735);
861  matrix_set(train->RAW, train->m+1, 9, 0, 1.0000000000000000);
862  matrix_set(train->RAW, train->m+1, 9, 1, 0.2290251898688216);
863  matrix_set(train->RAW, train->m+1, 9, 2, 0.4401981048538806);
864  matrix_set(train->RAW, train->m+1, 9, 3, 0.0884616753393881);
865  matrix_set(train->RAW, train->m+1, 9, 4, 0.8659836346403005);
866  matrix_set(train->RAW, train->m+1, 9, 5, 0.1028774221216107);
867  train->Z = train->RAW;
868 
869  matrix_set(test->RAW, test->m+1, 0, 0, 1.0000000000000000);
870  matrix_set(test->RAW, test->m+1, 0, 1, 0.4221779040953508);
871  matrix_set(test->RAW, test->m+1, 0, 2, 0.2491297759535341);
872  matrix_set(test->RAW, test->m+1, 0, 3, 0.3534695686769205);
873  matrix_set(test->RAW, test->m+1, 0, 4, 0.1843977014611545);
874  matrix_set(test->RAW, test->m+1, 0, 5, 0.2520805490786355);
875  matrix_set(test->RAW, test->m+1, 1, 0, 1.0000000000000000);
876  matrix_set(test->RAW, test->m+1, 1, 1, 0.1657896146622650);
877  matrix_set(test->RAW, test->m+1, 1, 2, 0.6189568847484389);
878  matrix_set(test->RAW, test->m+1, 1, 3, 0.0966039750517987);
879  matrix_set(test->RAW, test->m+1, 1, 4, 0.2271271152279254);
880  matrix_set(test->RAW, test->m+1, 1, 5, 0.6868351025871483);
881  matrix_set(test->RAW, test->m+1, 2, 0, 1.0000000000000000);
882  matrix_set(test->RAW, test->m+1, 2, 1, 0.2472125660924395);
883  matrix_set(test->RAW, test->m+1, 2, 2, 0.5090230605656835);
884  matrix_set(test->RAW, test->m+1, 2, 3, 0.7277927065471604);
885  matrix_set(test->RAW, test->m+1, 2, 4, 0.6985271697744179);
886  matrix_set(test->RAW, test->m+1, 2, 5, 0.6358202467851303);
887  matrix_set(test->RAW, test->m+1, 3, 0, 1.0000000000000000);
888  matrix_set(test->RAW, test->m+1, 3, 1, 0.7987328321610475);
889  matrix_set(test->RAW, test->m+1, 3, 2, 0.9000985899630121);
890  matrix_set(test->RAW, test->m+1, 3, 3, 0.6893982492936992);
891  matrix_set(test->RAW, test->m+1, 3, 4, 0.3663483426181376);
892  matrix_set(test->RAW, test->m+1, 3, 5, 0.6240335158701935);
893  matrix_set(test->RAW, test->m+1, 4, 0, 1.0000000000000000);
894  matrix_set(test->RAW, test->m+1, 4, 1, 0.9763647809741268);
895  matrix_set(test->RAW, test->m+1, 4, 2, 0.1140159498084029);
896  matrix_set(test->RAW, test->m+1, 4, 3, 0.8917076715220298);
897  matrix_set(test->RAW, test->m+1, 4, 4, 0.0724688230975385);
898  matrix_set(test->RAW, test->m+1, 4, 5, 0.3762619556957781);
899  matrix_set(test->RAW, test->m+1, 5, 0, 1.0000000000000000);
900  matrix_set(test->RAW, test->m+1, 5, 1, 0.5095430570208566);
901  matrix_set(test->RAW, test->m+1, 5, 2, 0.3920414766506218);
902  matrix_set(test->RAW, test->m+1, 5, 3, 0.7448958325189663);
903  matrix_set(test->RAW, test->m+1, 5, 4, 0.5028223670359105);
904  matrix_set(test->RAW, test->m+1, 5, 5, 0.0659571469966666);
905  matrix_set(test->RAW, test->m+1, 6, 0, 1.0000000000000000);
906  matrix_set(test->RAW, test->m+1, 6, 1, 0.1190008864254177);
907  matrix_set(test->RAW, test->m+1, 6, 2, 0.7735127328107272);
908  matrix_set(test->RAW, test->m+1, 6, 3, 0.7292497207505059);
909  matrix_set(test->RAW, test->m+1, 6, 4, 0.3385406475521640);
910  matrix_set(test->RAW, test->m+1, 6, 5, 0.7274062216238782);
911  matrix_set(test->RAW, test->m+1, 7, 0, 1.0000000000000000);
912  matrix_set(test->RAW, test->m+1, 7, 1, 0.5211738041619068);
913  matrix_set(test->RAW, test->m+1, 7, 2, 0.0437246682449493);
914  matrix_set(test->RAW, test->m+1, 7, 3, 0.0388180555183835);
915  matrix_set(test->RAW, test->m+1, 7, 4, 0.6866094956337303);
916  matrix_set(test->RAW, test->m+1, 7, 5, 0.7166516653360046);
917  test->Z = test->RAW;
918 
919  matrix_set(train->Sigma, 1, 0, 0, 0.9489494575279929);
920  matrix_set(train->Sigma, 1, 1, 0, 0.5162086311506285);
921  matrix_set(train->Sigma, 1, 2, 0, 0.6279732910944019);
922  matrix_set(train->Sigma, 1, 3, 0, 0.4247685972225844);
923  matrix_set(train->Sigma, 1, 4, 0, 0.9197312157223199);
924 
925  gensvm_kernel_postprocess(model, train, test);
926 
927  // start test code //
928  double eps = 1e-14;
929  mu_assert(fabs(matrix_get(test->Z, test->r+1, 0, 0) -
930  1.0000000000000000) < eps,
931  "Incorrect test->Z at 0, 0");
932  mu_assert(fabs(matrix_get(test->Z, test->r+1, 0, 1) -
933  1.7919375085966578) < eps,
934  "Incorrect test->Z at 0, 1");
935  mu_assert(fabs(matrix_get(test->Z, test->r+1, 0, 2) -
936  9.3749010505955841) < eps,
937  "Incorrect test->Z at 0, 2");
938  mu_assert(fabs(matrix_get(test->Z, test->r+1, 0, 3) -
939  5.4188812347396071) < eps,
940  "Incorrect test->Z at 0, 3");
941  mu_assert(fabs(matrix_get(test->Z, test->r+1, 0, 4) -
942  14.1749662709433490) < eps,
943  "Incorrect test->Z at 0, 4");
944  mu_assert(fabs(matrix_get(test->Z, test->r+1, 0, 5) -
945  2.0967148208956785) < eps,
946  "Incorrect test->Z at 0, 5");
947  mu_assert(fabs(matrix_get(test->Z, test->r+1, 1, 0) -
948  1.0000000000000000) < eps,
949  "Incorrect test->Z at 1, 0");
950  mu_assert(fabs(matrix_get(test->Z, test->r+1, 1, 1) -
951  1.4492639390367632) < eps,
952  "Incorrect test->Z at 1, 1");
953  mu_assert(fabs(matrix_get(test->Z, test->r+1, 1, 2) -
954  10.3598279425411341) < eps,
955  "Incorrect test->Z at 1, 2");
956  mu_assert(fabs(matrix_get(test->Z, test->r+1, 1, 3) -
957  4.9086179135381158) < eps,
958  "Incorrect test->Z at 1, 3");
959  mu_assert(fabs(matrix_get(test->Z, test->r+1, 1, 4) -
960  11.5763085861210531) < eps,
961  "Incorrect test->Z at 1, 4");
962  mu_assert(fabs(matrix_get(test->Z, test->r+1, 1, 5) -
963  2.4474439570061368) < eps,
964  "Incorrect test->Z at 1, 5");
965  mu_assert(fabs(matrix_get(test->Z, test->r+1, 2, 0) -
966  1.0000000000000000) < eps,
967  "Incorrect test->Z at 2, 0");
968  mu_assert(fabs(matrix_get(test->Z, test->r+1, 2, 1) -
969  1.7125210555223442) < eps,
970  "Incorrect test->Z at 2, 1");
971  mu_assert(fabs(matrix_get(test->Z, test->r+1, 2, 2) -
972  10.1267642728449463) < eps,
973  "Incorrect test->Z at 2, 2");
974  mu_assert(fabs(matrix_get(test->Z, test->r+1, 2, 3) -
975  7.4711312071081304) < eps,
976  "Incorrect test->Z at 2, 3");
977  mu_assert(fabs(matrix_get(test->Z, test->r+1, 2, 4) -
978  16.7954195638576316) < eps,
979  "Incorrect test->Z at 2, 4");
980  mu_assert(fabs(matrix_get(test->Z, test->r+1, 2, 5) -
981  2.9867291329866701) < eps,
982  "Incorrect test->Z at 2, 5");
983  mu_assert(fabs(matrix_get(test->Z, test->r+1, 3, 0) -
984  1.0000000000000000) < eps,
985  "Incorrect test->Z at 3, 0");
986  mu_assert(fabs(matrix_get(test->Z, test->r+1, 3, 1) -
987  1.5599347974839732) < eps,
988  "Incorrect test->Z at 3, 1");
989  mu_assert(fabs(matrix_get(test->Z, test->r+1, 3, 2) -
990  8.1287657651835250) < eps,
991  "Incorrect test->Z at 3, 2");
992  mu_assert(fabs(matrix_get(test->Z, test->r+1, 3, 3) -
993  4.4627669627170601) < eps,
994  "Incorrect test->Z at 3, 3");
995  mu_assert(fabs(matrix_get(test->Z, test->r+1, 3, 4) -
996  10.5382257909839403) < eps,
997  "Incorrect test->Z at 3, 4");
998  mu_assert(fabs(matrix_get(test->Z, test->r+1, 3, 5) -
999  2.0425829022313486) < eps,
1000  "Incorrect test->Z at 3, 5");
1001  mu_assert(fabs(matrix_get(test->Z, test->r+1, 4, 0) -
1002  1.0000000000000000) < eps,
1003  "Incorrect test->Z at 4, 0");
1004  mu_assert(fabs(matrix_get(test->Z, test->r+1, 4, 1) -
1005  1.1070615251210820) < eps,
1006  "Incorrect test->Z at 4, 1");
1007  mu_assert(fabs(matrix_get(test->Z, test->r+1, 4, 2) -
1008  3.8591733667970094) < eps,
1009  "Incorrect test->Z at 4, 2");
1010  mu_assert(fabs(matrix_get(test->Z, test->r+1, 4, 3) -
1011  3.1420027555179613) < eps,
1012  "Incorrect test->Z at 4, 3");
1013  mu_assert(fabs(matrix_get(test->Z, test->r+1, 4, 4) -
1014  7.3657520580430189) < eps,
1015  "Incorrect test->Z at 4, 4");
1016  mu_assert(fabs(matrix_get(test->Z, test->r+1, 4, 5) -
1017  1.0570891668650841) < eps,
1018  "Incorrect test->Z at 4, 5");
1019  mu_assert(fabs(matrix_get(test->Z, test->r+1, 5, 0) -
1020  1.0000000000000000) < eps,
1021  "Incorrect test->Z at 5, 0");
1022  mu_assert(fabs(matrix_get(test->Z, test->r+1, 5, 1) -
1023  2.0048972078646314) < eps,
1024  "Incorrect test->Z at 5, 1");
1025  mu_assert(fabs(matrix_get(test->Z, test->r+1, 5, 2) -
1026  8.5523796391619555) < eps,
1027  "Incorrect test->Z at 5, 2");
1028  mu_assert(fabs(matrix_get(test->Z, test->r+1, 5, 3) -
1029  6.2297195520069808) < eps,
1030  "Incorrect test->Z at 5, 3");
1031  mu_assert(fabs(matrix_get(test->Z, test->r+1, 5, 4) -
1032  16.1775074795210649) < eps,
1033  "Incorrect test->Z at 5, 4");
1034  mu_assert(fabs(matrix_get(test->Z, test->r+1, 5, 5) -
1035  2.0441111634728997) < eps,
1036  "Incorrect test->Z at 5, 5");
1037  mu_assert(fabs(matrix_get(test->Z, test->r+1, 6, 0) -
1038  1.0000000000000000) < eps,
1039  "Incorrect test->Z at 6, 0");
1040  mu_assert(fabs(matrix_get(test->Z, test->r+1, 6, 1) -
1041  1.2742361109643845) < eps,
1042  "Incorrect test->Z at 6, 1");
1043  mu_assert(fabs(matrix_get(test->Z, test->r+1, 6, 2) -
1044  10.4770471122282736) < eps,
1045  "Incorrect test->Z at 6, 2");
1046  mu_assert(fabs(matrix_get(test->Z, test->r+1, 6, 3) -
1047  6.4647232181010859) < eps,
1048  "Incorrect test->Z at 6, 3");
1049  mu_assert(fabs(matrix_get(test->Z, test->r+1, 6, 4) -
1050  12.6115089203184212) < eps,
1051  "Incorrect test->Z at 6, 4");
1052  mu_assert(fabs(matrix_get(test->Z, test->r+1, 6, 5) -
1053  3.0535665607782896) < eps,
1054  "Incorrect test->Z at 6, 5");
1055  mu_assert(fabs(matrix_get(test->Z, test->r+1, 7, 0) -
1056  1.0000000000000000) < eps,
1057  "Incorrect test->Z at 7, 0");
1058  mu_assert(fabs(matrix_get(test->Z, test->r+1, 7, 1) -
1059  1.3901612934200134) < eps,
1060  "Incorrect test->Z at 7, 1");
1061  mu_assert(fabs(matrix_get(test->Z, test->r+1, 7, 2) -
1062  6.1897209583367783) < eps,
1063  "Incorrect test->Z at 7, 2");
1064  mu_assert(fabs(matrix_get(test->Z, test->r+1, 7, 3) -
1065  3.8589726502511379) < eps,
1066  "Incorrect test->Z at 7, 3");
1067  mu_assert(fabs(matrix_get(test->Z, test->r+1, 7, 4) -
1068  11.0809129571265199) < eps,
1069  "Incorrect test->Z at 7, 4");
1070  mu_assert(fabs(matrix_get(test->Z, test->r+1, 7, 5) -
1071  1.5298881436115606) < eps,
1072  "Incorrect test->Z at 7, 5");
1073  // end test code //
1074 
1075  gensvm_free_model(model);
1076  gensvm_free_data(train);
1077  gensvm_free_data(test);
1078 
1079  return NULL;
1080 }
1081 
1082 char *test_kernel_compute_rbf()
1083 {
1084  struct GenModel *model = gensvm_init_model();
1085  struct GenData *data = gensvm_init_data();
1086 
1087  // setup //
1088  data->n = 10;
1089  data->m = 3;
1090  data->RAW = Calloc(double, data->n * (data->m + 1));
1091 
1092  model->n = 10;
1093  model->m = 3;
1094  model->kerneltype = K_RBF;
1095  model->gamma = 0.348;
1096 
1097  double *K = Calloc(double, data->n * data->n);
1098 
1099  matrix_set(data->RAW, data->m+1, 0, 0, 1.0);
1100  matrix_set(data->RAW, data->m+1, 0, 1, 0.8056271362589000);
1101  matrix_set(data->RAW, data->m+1, 0, 2, 0.4874175854113872);
1102  matrix_set(data->RAW, data->m+1, 0, 3, 0.4453015882771756);
1103  matrix_set(data->RAW, data->m+1, 1, 0, 1.0);
1104  matrix_set(data->RAW, data->m+1, 1, 1, 0.7940590105180981);
1105  matrix_set(data->RAW, data->m+1, 1, 2, 0.1861049005485224);
1106  matrix_set(data->RAW, data->m+1, 1, 3, 0.8469394287449229);
1107  matrix_set(data->RAW, data->m+1, 2, 0, 1.0);
1108  matrix_set(data->RAW, data->m+1, 2, 1, 0.0294257611061681);
1109  matrix_set(data->RAW, data->m+1, 2, 2, 0.0242717976065267);
1110  matrix_set(data->RAW, data->m+1, 2, 3, 0.5039128672814752);
1111  matrix_set(data->RAW, data->m+1, 3, 0, 1.0);
1112  matrix_set(data->RAW, data->m+1, 3, 1, 0.1746563833537603);
1113  matrix_set(data->RAW, data->m+1, 3, 2, 0.9135736087631979);
1114  matrix_set(data->RAW, data->m+1, 3, 3, 0.5270258081021366);
1115  matrix_set(data->RAW, data->m+1, 4, 0, 1.0);
1116  matrix_set(data->RAW, data->m+1, 4, 1, 0.0022298761599785);
1117  matrix_set(data->RAW, data->m+1, 4, 2, 0.3773482059713607);
1118  matrix_set(data->RAW, data->m+1, 4, 3, 0.8009654729622842);
1119  matrix_set(data->RAW, data->m+1, 5, 0, 1.0);
1120  matrix_set(data->RAW, data->m+1, 5, 1, 0.6638830667081945);
1121  matrix_set(data->RAW, data->m+1, 5, 2, 0.6467607601353914);
1122  matrix_set(data->RAW, data->m+1, 5, 3, 0.0434948735457108);
1123  matrix_set(data->RAW, data->m+1, 6, 0, 1.0);
1124  matrix_set(data->RAW, data->m+1, 6, 1, 0.0770493004546461);
1125  matrix_set(data->RAW, data->m+1, 6, 2, 0.3699566427075194);
1126  matrix_set(data->RAW, data->m+1, 6, 3, 0.7863539761080217);
1127  matrix_set(data->RAW, data->m+1, 7, 0, 1.0);
1128  matrix_set(data->RAW, data->m+1, 7, 1, 0.2685233952731509);
1129  matrix_set(data->RAW, data->m+1, 7, 2, 0.8539966432782011);
1130  matrix_set(data->RAW, data->m+1, 7, 3, 0.0967159557826836);
1131  matrix_set(data->RAW, data->m+1, 8, 0, 1.0);
1132  matrix_set(data->RAW, data->m+1, 8, 1, 0.1163951898554611);
1133  matrix_set(data->RAW, data->m+1, 8, 2, 0.7667861436369238);
1134  matrix_set(data->RAW, data->m+1, 8, 3, 0.5031912600213351);
1135  matrix_set(data->RAW, data->m+1, 9, 0, 1.0);
1136  matrix_set(data->RAW, data->m+1, 9, 1, 0.2290251898688216);
1137  matrix_set(data->RAW, data->m+1, 9, 2, 0.4401981048538806);
1138  matrix_set(data->RAW, data->m+1, 9, 3, 0.0884616753393881);
1139 
1140  // end setup //
1141 
1142  // start test code //
1143  double eps = 1e-14;
1144  gensvm_kernel_compute(model, data, K);
1145 
1146  mu_assert(fabs(matrix_get(K, data->n, 0, 0) -
1147  1.0000000000000000) < eps,
1148  "Incorrect K at 0, 0");
1149  mu_assert(fabs(matrix_get(K, data->n, 0, 1) -
1150  0.9159640457437349) < eps,
1151  "Incorrect K at 0, 1");
1152  mu_assert(fabs(matrix_get(K, data->n, 0, 2) -
1153  0.7516316505770226) < eps,
1154  "Incorrect K at 0, 2");
1155  mu_assert(fabs(matrix_get(K, data->n, 0, 3) -
1156  0.8154041985130495) < eps,
1157  "Incorrect K at 0, 3");
1158  mu_assert(fabs(matrix_get(K, data->n, 0, 4) -
1159  0.7612049732149070) < eps,
1160  "Incorrect K at 0, 4");
1161  mu_assert(fabs(matrix_get(K, data->n, 0, 5) -
1162  0.9305199788157297) < eps,
1163  "Incorrect K at 0, 5");
1164  mu_assert(fabs(matrix_get(K, data->n, 0, 6) -
1165  0.7945280927801784) < eps,
1166  "Incorrect K at 0, 6");
1167  mu_assert(fabs(matrix_get(K, data->n, 0, 7) -
1168  0.8274209897573236) < eps,
1169  "Incorrect K at 0, 7");
1170  mu_assert(fabs(matrix_get(K, data->n, 0, 8) -
1171  0.8239539297657018) < eps,
1172  "Incorrect K at 0, 8");
1173  mu_assert(fabs(matrix_get(K, data->n, 0, 9) -
1174  0.8514726457528513) < eps,
1175  "Incorrect K at 0, 9");
1176  mu_assert(fabs(matrix_get(K, data->n, 1, 0) -
1177  0.9159640457437349) < eps,
1178  "Incorrect K at 1, 0");
1179  mu_assert(fabs(matrix_get(K, data->n, 1, 1) -
1180  1.0000000000000000) < eps,
1181  "Incorrect K at 1, 1");
1182  mu_assert(fabs(matrix_get(K, data->n, 1, 2) -
1183  0.7760600552154528) < eps,
1184  "Incorrect K at 1, 2");
1185  mu_assert(fabs(matrix_get(K, data->n, 1, 3) -
1186  0.7023700752771812) < eps,
1187  "Incorrect K at 1, 3");
1188  mu_assert(fabs(matrix_get(K, data->n, 1, 4) -
1189  0.7932181642748459) < eps,
1190  "Incorrect K at 1, 4");
1191  mu_assert(fabs(matrix_get(K, data->n, 1, 5) -
1192  0.7375760206683935) < eps,
1193  "Incorrect K at 1, 5");
1194  mu_assert(fabs(matrix_get(K, data->n, 1, 6) -
1195  0.8253497074841124) < eps,
1196  "Incorrect K at 1, 6");
1197  mu_assert(fabs(matrix_get(K, data->n, 1, 7) -
1198  0.6394060322576254) < eps,
1199  "Incorrect K at 1, 7");
1200  mu_assert(fabs(matrix_get(K, data->n, 1, 8) -
1201  0.7274031225620441) < eps,
1202  "Incorrect K at 1, 8");
1203  mu_assert(fabs(matrix_get(K, data->n, 1, 9) -
1204  0.7162170274961248) < eps,
1205  "Incorrect K at 1, 9");
1206  mu_assert(fabs(matrix_get(K, data->n, 2, 0) -
1207  0.7516316505770226) < eps,
1208  "Incorrect K at 2, 0");
1209  mu_assert(fabs(matrix_get(K, data->n, 2, 1) -
1210  0.7760600552154528) < eps,
1211  "Incorrect K at 2, 1");
1212  mu_assert(fabs(matrix_get(K, data->n, 2, 2) -
1213  1.0000000000000000) < eps,
1214  "Incorrect K at 2, 2");
1215  mu_assert(fabs(matrix_get(K, data->n, 2, 3) -
1216  0.7537124265723788) < eps,
1217  "Incorrect K at 2, 3");
1218  mu_assert(fabs(matrix_get(K, data->n, 2, 4) -
1219  0.9283488505800269) < eps,
1220  "Incorrect K at 2, 4");
1221  mu_assert(fabs(matrix_get(K, data->n, 2, 5) -
1222  0.7056043340833220) < eps,
1223  "Incorrect K at 2, 5");
1224  mu_assert(fabs(matrix_get(K, data->n, 2, 6) -
1225  0.9322674240595221) < eps,
1226  "Incorrect K at 2, 6");
1227  mu_assert(fabs(matrix_get(K, data->n, 2, 7) -
1228  0.7282038382529162) < eps,
1229  "Incorrect K at 2, 7");
1230  mu_assert(fabs(matrix_get(K, data->n, 2, 8) -
1231  0.8232508450896556) < eps,
1232  "Incorrect K at 2, 8");
1233  mu_assert(fabs(matrix_get(K, data->n, 2, 9) -
1234  0.8744753760805232) < eps,
1235  "Incorrect K at 2, 9");
1236  mu_assert(fabs(matrix_get(K, data->n, 3, 0) -
1237  0.8154041985130495) < eps,
1238  "Incorrect K at 3, 0");
1239  mu_assert(fabs(matrix_get(K, data->n, 3, 1) -
1240  0.7023700752771812) < eps,
1241  "Incorrect K at 3, 1");
1242  mu_assert(fabs(matrix_get(K, data->n, 3, 2) -
1243  0.7537124265723788) < eps,
1244  "Incorrect K at 3, 2");
1245  mu_assert(fabs(matrix_get(K, data->n, 3, 3) -
1246  1.0000000000000000) < eps,
1247  "Incorrect K at 3, 3");
1248  mu_assert(fabs(matrix_get(K, data->n, 3, 4) -
1249  0.8723850250880842) < eps,
1250  "Incorrect K at 3, 4");
1251  mu_assert(fabs(matrix_get(K, data->n, 3, 5) -
1252  0.8274320954451651) < eps,
1253  "Incorrect K at 3, 5");
1254  mu_assert(fabs(matrix_get(K, data->n, 3, 6) -
1255  0.8784822458273475) < eps,
1256  "Incorrect K at 3, 6");
1257  mu_assert(fabs(matrix_get(K, data->n, 3, 7) -
1258  0.9335699405227060) < eps,
1259  "Incorrect K at 3, 7");
1260  mu_assert(fabs(matrix_get(K, data->n, 3, 8) -
1261  0.9911621491714698) < eps,
1262  "Incorrect K at 3, 8");
1263  mu_assert(fabs(matrix_get(K, data->n, 3, 9) -
1264  0.8642062408184789) < eps,
1265  "Incorrect K at 3, 9");
1266  mu_assert(fabs(matrix_get(K, data->n, 4, 0) -
1267  0.7612049732149070) < eps,
1268  "Incorrect K at 4, 0");
1269  mu_assert(fabs(matrix_get(K, data->n, 4, 1) -
1270  0.7932181642748459) < eps,
1271  "Incorrect K at 4, 1");
1272  mu_assert(fabs(matrix_get(K, data->n, 4, 2) -
1273  0.9283488505800269) < eps,
1274  "Incorrect K at 4, 2");
1275  mu_assert(fabs(matrix_get(K, data->n, 4, 3) -
1276  0.8723850250880842) < eps,
1277  "Incorrect K at 4, 3");
1278  mu_assert(fabs(matrix_get(K, data->n, 4, 4) -
1279  1.0000000000000000) < eps,
1280  "Incorrect K at 4, 4");
1281  mu_assert(fabs(matrix_get(K, data->n, 4, 5) -
1282  0.6857259898857532) < eps,
1283  "Incorrect K at 4, 5");
1284  mu_assert(fabs(matrix_get(K, data->n, 4, 6) -
1285  0.9979606873291865) < eps,
1286  "Incorrect K at 4, 6");
1287  mu_assert(fabs(matrix_get(K, data->n, 4, 7) -
1288  0.7585568540994299) < eps,
1289  "Incorrect K at 4, 7");
1290  mu_assert(fabs(matrix_get(K, data->n, 4, 8) -
1291  0.9156042422655802) < eps,
1292  "Incorrect K at 4, 8");
1293  mu_assert(fabs(matrix_get(K, data->n, 4, 9) -
1294  0.8220610108488617) < eps,
1295  "Incorrect K at 4, 9");
1296  mu_assert(fabs(matrix_get(K, data->n, 5, 0) -
1297  0.9305199788157297) < eps,
1298  "Incorrect K at 5, 0");
1299  mu_assert(fabs(matrix_get(K, data->n, 5, 1) -
1300  0.7375760206683935) < eps,
1301  "Incorrect K at 5, 1");
1302  mu_assert(fabs(matrix_get(K, data->n, 5, 2) -
1303  0.7056043340833220) < eps,
1304  "Incorrect K at 5, 2");
1305  mu_assert(fabs(matrix_get(K, data->n, 5, 3) -
1306  0.8274320954451651) < eps,
1307  "Incorrect K at 5, 3");
1308  mu_assert(fabs(matrix_get(K, data->n, 5, 4) -
1309  0.6857259898857532) < eps,
1310  "Incorrect K at 5, 4");
1311  mu_assert(fabs(matrix_get(K, data->n, 5, 5) -
1312  1.0000000000000000) < eps,
1313  "Incorrect K at 5, 5");
1314  mu_assert(fabs(matrix_get(K, data->n, 5, 6) -
1315  0.7128058155310608) < eps,
1316  "Incorrect K at 5, 6");
1317  mu_assert(fabs(matrix_get(K, data->n, 5, 7) -
1318  0.9320891767185483) < eps,
1319  "Incorrect K at 5, 7");
1320  mu_assert(fabs(matrix_get(K, data->n, 5, 8) -
1321  0.8328818339901494) < eps,
1322  "Incorrect K at 5, 8");
1323  mu_assert(fabs(matrix_get(K, data->n, 5, 9) -
1324  0.9218622704537242) < eps,
1325  "Incorrect K at 5, 9");
1326  mu_assert(fabs(matrix_get(K, data->n, 6, 0) -
1327  0.7945280927801784) < eps,
1328  "Incorrect K at 6, 0");
1329  mu_assert(fabs(matrix_get(K, data->n, 6, 1) -
1330  0.8253497074841124) < eps,
1331  "Incorrect K at 6, 1");
1332  mu_assert(fabs(matrix_get(K, data->n, 6, 2) -
1333  0.9322674240595221) < eps,
1334  "Incorrect K at 6, 2");
1335  mu_assert(fabs(matrix_get(K, data->n, 6, 3) -
1336  0.8784822458273475) < eps,
1337  "Incorrect K at 6, 3");
1338  mu_assert(fabs(matrix_get(K, data->n, 6, 4) -
1339  0.9979606873291865) < eps,
1340  "Incorrect K at 6, 4");
1341  mu_assert(fabs(matrix_get(K, data->n, 6, 5) -
1342  0.7128058155310608) < eps,
1343  "Incorrect K at 6, 5");
1344  mu_assert(fabs(matrix_get(K, data->n, 6, 6) -
1345  1.0000000000000000) < eps,
1346  "Incorrect K at 6, 6");
1347  mu_assert(fabs(matrix_get(K, data->n, 6, 7) -
1348  0.7712042211054879) < eps,
1349  "Incorrect K at 6, 7");
1350  mu_assert(fabs(matrix_get(K, data->n, 6, 8) -
1351  0.9201278964602475) < eps,
1352  "Incorrect K at 6, 8");
1353  mu_assert(fabs(matrix_get(K, data->n, 6, 9) -
1354  0.8358974835836517) < eps,
1355  "Incorrect K at 6, 9");
1356  mu_assert(fabs(matrix_get(K, data->n, 7, 0) -
1357  0.8274209897573236) < eps,
1358  "Incorrect K at 7, 0");
1359  mu_assert(fabs(matrix_get(K, data->n, 7, 1) -
1360  0.6394060322576254) < eps,
1361  "Incorrect K at 7, 1");
1362  mu_assert(fabs(matrix_get(K, data->n, 7, 2) -
1363  0.7282038382529162) < eps,
1364  "Incorrect K at 7, 2");
1365  mu_assert(fabs(matrix_get(K, data->n, 7, 3) -
1366  0.9335699405227060) < eps,
1367  "Incorrect K at 7, 3");
1368  mu_assert(fabs(matrix_get(K, data->n, 7, 4) -
1369  0.7585568540994299) < eps,
1370  "Incorrect K at 7, 4");
1371  mu_assert(fabs(matrix_get(K, data->n, 7, 5) -
1372  0.9320891767185483) < eps,
1373  "Incorrect K at 7, 5");
1374  mu_assert(fabs(matrix_get(K, data->n, 7, 6) -
1375  0.7712042211054879) < eps,
1376  "Incorrect K at 7, 6");
1377  mu_assert(fabs(matrix_get(K, data->n, 7, 7) -
1378  1.0000000000000000) < eps,
1379  "Incorrect K at 7, 7");
1380  mu_assert(fabs(matrix_get(K, data->n, 7, 8) -
1381  0.9340756478568407) < eps,
1382  "Incorrect K at 7, 8");
1383  mu_assert(fabs(matrix_get(K, data->n, 7, 9) -
1384  0.9416191361969405) < eps,
1385  "Incorrect K at 7, 9");
1386  mu_assert(fabs(matrix_get(K, data->n, 8, 0) -
1387  0.8239539297657018) < eps,
1388  "Incorrect K at 8, 0");
1389  mu_assert(fabs(matrix_get(K, data->n, 8, 1) -
1390  0.7274031225620441) < eps,
1391  "Incorrect K at 8, 1");
1392  mu_assert(fabs(matrix_get(K, data->n, 8, 2) -
1393  0.8232508450896556) < eps,
1394  "Incorrect K at 8, 2");
1395  mu_assert(fabs(matrix_get(K, data->n, 8, 3) -
1396  0.9911621491714698) < eps,
1397  "Incorrect K at 8, 3");
1398  mu_assert(fabs(matrix_get(K, data->n, 8, 4) -
1399  0.9156042422655802) < eps,
1400  "Incorrect K at 8, 4");
1401  mu_assert(fabs(matrix_get(K, data->n, 8, 5) -
1402  0.8328818339901494) < eps,
1403  "Incorrect K at 8, 5");
1404  mu_assert(fabs(matrix_get(K, data->n, 8, 6) -
1405  0.9201278964602475) < eps,
1406  "Incorrect K at 8, 6");
1407  mu_assert(fabs(matrix_get(K, data->n, 8, 7) -
1408  0.9340756478568407) < eps,
1409  "Incorrect K at 8, 7");
1410  mu_assert(fabs(matrix_get(K, data->n, 8, 8) -
1411  1.0000000000000000) < eps,
1412  "Incorrect K at 8, 8");
1413  mu_assert(fabs(matrix_get(K, data->n, 8, 9) -
1414  0.9035820400773296) < eps,
1415  "Incorrect K at 8, 9");
1416  mu_assert(fabs(matrix_get(K, data->n, 9, 0) -
1417  0.8514726457528513) < eps,
1418  "Incorrect K at 9, 0");
1419  mu_assert(fabs(matrix_get(K, data->n, 9, 1) -
1420  0.7162170274961248) < eps,
1421  "Incorrect K at 9, 1");
1422  mu_assert(fabs(matrix_get(K, data->n, 9, 2) -
1423  0.8744753760805232) < eps,
1424  "Incorrect K at 9, 2");
1425  mu_assert(fabs(matrix_get(K, data->n, 9, 3) -
1426  0.8642062408184789) < eps,
1427  "Incorrect K at 9, 3");
1428  mu_assert(fabs(matrix_get(K, data->n, 9, 4) -
1429  0.8220610108488617) < eps,
1430  "Incorrect K at 9, 4");
1431  mu_assert(fabs(matrix_get(K, data->n, 9, 5) -
1432  0.9218622704537242) < eps,
1433  "Incorrect K at 9, 5");
1434  mu_assert(fabs(matrix_get(K, data->n, 9, 6) -
1435  0.8358974835836517) < eps,
1436  "Incorrect K at 9, 6");
1437  mu_assert(fabs(matrix_get(K, data->n, 9, 7) -
1438  0.9416191361969405) < eps,
1439  "Incorrect K at 9, 7");
1440  mu_assert(fabs(matrix_get(K, data->n, 9, 8) -
1441  0.9035820400773296) < eps,
1442  "Incorrect K at 9, 8");
1443  mu_assert(fabs(matrix_get(K, data->n, 9, 9) -
1444  1.0000000000000000) < eps,
1445  "Incorrect K at 9, 9");
1446 
1447  // end test code //
1448 
1449  free(K);
1450  gensvm_free_data(data);
1451  gensvm_free_model(model);
1452 
1453  return NULL;
1454 }
1455 
1456 char *test_kernel_compute_poly()
1457 {
1458  struct GenModel *model = gensvm_init_model();
1459  struct GenData *data = gensvm_init_data();
1460 
1461  // setup //
1462  data->n = 10;
1463  data->m = 3;
1464  data->RAW = Calloc(double, data->n * (data->m + 1));
1465 
1466  model->n = 10;
1467  model->m = 3;
1468  model->kerneltype = K_POLY;
1469  model->gamma = 1.5;
1470  model->coef = 3.0;
1471  model->degree = 1.78;
1472 
1473  double *K = Calloc(double, data->n * data->n);
1474 
1475  matrix_set(data->RAW, data->m+1, 0, 0, 1.0);
1476  matrix_set(data->RAW, data->m+1, 0, 1, 0.8056271362589000);
1477  matrix_set(data->RAW, data->m+1, 0, 2, 0.4874175854113872);
1478  matrix_set(data->RAW, data->m+1, 0, 3, 0.4453015882771756);
1479  matrix_set(data->RAW, data->m+1, 1, 0, 1.0);
1480  matrix_set(data->RAW, data->m+1, 1, 1, 0.7940590105180981);
1481  matrix_set(data->RAW, data->m+1, 1, 2, 0.1861049005485224);
1482  matrix_set(data->RAW, data->m+1, 1, 3, 0.8469394287449229);
1483  matrix_set(data->RAW, data->m+1, 2, 0, 1.0);
1484  matrix_set(data->RAW, data->m+1, 2, 1, 0.0294257611061681);
1485  matrix_set(data->RAW, data->m+1, 2, 2, 0.0242717976065267);
1486  matrix_set(data->RAW, data->m+1, 2, 3, 0.5039128672814752);
1487  matrix_set(data->RAW, data->m+1, 3, 0, 1.0);
1488  matrix_set(data->RAW, data->m+1, 3, 1, 0.1746563833537603);
1489  matrix_set(data->RAW, data->m+1, 3, 2, 0.9135736087631979);
1490  matrix_set(data->RAW, data->m+1, 3, 3, 0.5270258081021366);
1491  matrix_set(data->RAW, data->m+1, 4, 0, 1.0);
1492  matrix_set(data->RAW, data->m+1, 4, 1, 0.0022298761599785);
1493  matrix_set(data->RAW, data->m+1, 4, 2, 0.3773482059713607);
1494  matrix_set(data->RAW, data->m+1, 4, 3, 0.8009654729622842);
1495  matrix_set(data->RAW, data->m+1, 5, 0, 1.0);
1496  matrix_set(data->RAW, data->m+1, 5, 1, 0.6638830667081945);
1497  matrix_set(data->RAW, data->m+1, 5, 2, 0.6467607601353914);
1498  matrix_set(data->RAW, data->m+1, 5, 3, 0.0434948735457108);
1499  matrix_set(data->RAW, data->m+1, 6, 0, 1.0);
1500  matrix_set(data->RAW, data->m+1, 6, 1, 0.0770493004546461);
1501  matrix_set(data->RAW, data->m+1, 6, 2, 0.3699566427075194);
1502  matrix_set(data->RAW, data->m+1, 6, 3, 0.7863539761080217);
1503  matrix_set(data->RAW, data->m+1, 7, 0, 1.0);
1504  matrix_set(data->RAW, data->m+1, 7, 1, 0.2685233952731509);
1505  matrix_set(data->RAW, data->m+1, 7, 2, 0.8539966432782011);
1506  matrix_set(data->RAW, data->m+1, 7, 3, 0.0967159557826836);
1507  matrix_set(data->RAW, data->m+1, 8, 0, 1.0);
1508  matrix_set(data->RAW, data->m+1, 8, 1, 0.1163951898554611);
1509  matrix_set(data->RAW, data->m+1, 8, 2, 0.7667861436369238);
1510  matrix_set(data->RAW, data->m+1, 8, 3, 0.5031912600213351);
1511  matrix_set(data->RAW, data->m+1, 9, 0, 1.0);
1512  matrix_set(data->RAW, data->m+1, 9, 1, 0.2290251898688216);
1513  matrix_set(data->RAW, data->m+1, 9, 2, 0.4401981048538806);
1514  matrix_set(data->RAW, data->m+1, 9, 3, 0.0884616753393881);
1515 
1516  // end setup //
1517 
1518  // start test code //
1519  double eps = 1e-14;
1520  gensvm_kernel_compute(model, data, K);
1521 
1522  mu_assert(fabs(matrix_get(K, data->n, 0, 0) -
1523  15.2859595967658617) < eps,
1524  "Incorrect K at 0, 0");
1525  mu_assert(fabs(matrix_get(K, data->n, 0, 1) -
1526  15.4864409009677200) < eps,
1527  "Incorrect K at 0, 1");
1528  mu_assert(fabs(matrix_get(K, data->n, 0, 2) -
1529  8.7847919771675169) < eps,
1530  "Incorrect K at 0, 2");
1531  mu_assert(fabs(matrix_get(K, data->n, 0, 3) -
1532  13.0338783338890352) < eps,
1533  "Incorrect K at 0, 3");
1534  mu_assert(fabs(matrix_get(K, data->n, 0, 4) -
1535  10.8336465195648390) < eps,
1536  "Incorrect K at 0, 4");
1537  mu_assert(fabs(matrix_get(K, data->n, 0, 5) -
1538  13.4376986903046944) < eps,
1539  "Incorrect K at 0, 5");
1540  mu_assert(fabs(matrix_get(K, data->n, 0, 6) -
1541  11.2170859716846412) < eps,
1542  "Incorrect K at 0, 6");
1543  mu_assert(fabs(matrix_get(K, data->n, 0, 7) -
1544  11.8649726239060982) < eps,
1545  "Incorrect K at 0, 7");
1546  mu_assert(fabs(matrix_get(K, data->n, 0, 8) -
1547  11.9910642907247134) < eps,
1548  "Incorrect K at 0, 8");
1549  mu_assert(fabs(matrix_get(K, data->n, 0, 9) -
1550  10.0579319882111839) < eps,
1551  "Incorrect K at 0, 9");
1552  mu_assert(fabs(matrix_get(K, data->n, 1, 0) -
1553  15.4864409009677200) < eps,
1554  "Incorrect K at 1, 0");
1555  mu_assert(fabs(matrix_get(K, data->n, 1, 1) -
1556  18.0085663057827681) < eps,
1557  "Incorrect K at 1, 1");
1558  mu_assert(fabs(matrix_get(K, data->n, 1, 2) -
1559  10.1772186353572813) < eps,
1560  "Incorrect K at 1, 2");
1561  mu_assert(fabs(matrix_get(K, data->n, 1, 3) -
1562  12.4990693290747981) < eps,
1563  "Incorrect K at 1, 3");
1564  mu_assert(fabs(matrix_get(K, data->n, 1, 4) -
1565  12.4611344803924595) < eps,
1566  "Incorrect K at 1, 4");
1567  mu_assert(fabs(matrix_get(K, data->n, 1, 5) -
1568  11.9338476573364556) < eps,
1569  "Incorrect K at 1, 5");
1570  mu_assert(fabs(matrix_get(K, data->n, 1, 6) -
1571  12.8317520536684597) < eps,
1572  "Incorrect K at 1, 6");
1573  mu_assert(fabs(matrix_get(K, data->n, 1, 7) -
1574  10.1728085503000116) < eps,
1575  "Incorrect K at 1, 7");
1576  mu_assert(fabs(matrix_get(K, data->n, 1, 8) -
1577  11.7519359337010130) < eps,
1578  "Incorrect K at 1, 8");
1579  mu_assert(fabs(matrix_get(K, data->n, 1, 9) -
1580  9.3372389753548415) < eps,
1581  "Incorrect K at 1, 9");
1582  mu_assert(fabs(matrix_get(K, data->n, 2, 0) -
1583  8.7847919771675169) < eps,
1584  "Incorrect K at 2, 0");
1585  mu_assert(fabs(matrix_get(K, data->n, 2, 1) -
1586  10.1772186353572813) < eps,
1587  "Incorrect K at 2, 1");
1588  mu_assert(fabs(matrix_get(K, data->n, 2, 2) -
1589  8.7533569584420832) < eps,
1590  "Incorrect K at 2, 2");
1591  mu_assert(fabs(matrix_get(K, data->n, 2, 3) -
1592  9.0141355927477953) < eps,
1593  "Incorrect K at 2, 3");
1594  mu_assert(fabs(matrix_get(K, data->n, 2, 4) -
1595  9.8706020767326290) < eps,
1596  "Incorrect K at 2, 4");
1597  mu_assert(fabs(matrix_get(K, data->n, 2, 5) -
1598  7.4311529847899962) < eps,
1599  "Incorrect K at 2, 5");
1600  mu_assert(fabs(matrix_get(K, data->n, 2, 6) -
1601  9.8317460227342295) < eps,
1602  "Incorrect K at 2, 6");
1603  mu_assert(fabs(matrix_get(K, data->n, 2, 7) -
1604  7.5616330506213130) < eps,
1605  "Incorrect K at 2, 7");
1606  mu_assert(fabs(matrix_get(K, data->n, 2, 8) -
1607  8.8935156801233308) < eps,
1608  "Incorrect K at 2, 8");
1609  mu_assert(fabs(matrix_get(K, data->n, 2, 9) -
1610  7.4623650201501697) < eps,
1611  "Incorrect K at 2, 9");
1612  mu_assert(fabs(matrix_get(K, data->n, 3, 0) -
1613  13.0338783338890352) < eps,
1614  "Incorrect K at 3, 0");
1615  mu_assert(fabs(matrix_get(K, data->n, 3, 1) -
1616  12.4990693290747981) < eps,
1617  "Incorrect K at 3, 1");
1618  mu_assert(fabs(matrix_get(K, data->n, 3, 2) -
1619  9.0141355927477953) < eps,
1620  "Incorrect K at 3, 2");
1621  mu_assert(fabs(matrix_get(K, data->n, 3, 3) -
1622  15.8010293983089412) < eps,
1623  "Incorrect K at 3, 3");
1624  mu_assert(fabs(matrix_get(K, data->n, 3, 4) -
1625  12.5976572300545939) < eps,
1626  "Incorrect K at 3, 4");
1627  mu_assert(fabs(matrix_get(K, data->n, 3, 5) -
1628  12.2952603928598840) < eps,
1629  "Incorrect K at 3, 5");
1630  mu_assert(fabs(matrix_get(K, data->n, 3, 6) -
1631  12.5864308488164252) < eps,
1632  "Incorrect K at 3, 6");
1633  mu_assert(fabs(matrix_get(K, data->n, 3, 7) -
1634  13.5095269679848702) < eps,
1635  "Incorrect K at 3, 7");
1636  mu_assert(fabs(matrix_get(K, data->n, 3, 8) -
1637  14.4248904770779447) < eps,
1638  "Incorrect K at 3, 8");
1639  mu_assert(fabs(matrix_get(K, data->n, 3, 9) -
1640  10.4303067289663023) < eps,
1641  "Incorrect K at 3, 9");
1642  mu_assert(fabs(matrix_get(K, data->n, 4, 0) -
1643  10.8336465195648390) < eps,
1644  "Incorrect K at 4, 0");
1645  mu_assert(fabs(matrix_get(K, data->n, 4, 1) -
1646  12.4611344803924595) < eps,
1647  "Incorrect K at 4, 1");
1648  mu_assert(fabs(matrix_get(K, data->n, 4, 2) -
1649  9.8706020767326290) < eps,
1650  "Incorrect K at 4, 2");
1651  mu_assert(fabs(matrix_get(K, data->n, 4, 3) -
1652  12.5976572300545939) < eps,
1653  "Incorrect K at 4, 3");
1654  mu_assert(fabs(matrix_get(K, data->n, 4, 4) -
1655  12.7332028710821596) < eps,
1656  "Incorrect K at 4, 4");
1657  mu_assert(fabs(matrix_get(K, data->n, 4, 5) -
1658  8.9267358166744923) < eps,
1659  "Incorrect K at 4, 5");
1660  mu_assert(fabs(matrix_get(K, data->n, 4, 6) -
1661  12.6168065443066961) < eps,
1662  "Incorrect K at 4, 6");
1663  mu_assert(fabs(matrix_get(K, data->n, 4, 7) -
1664  9.7796024413467819) < eps,
1665  "Incorrect K at 4, 7");
1666  mu_assert(fabs(matrix_get(K, data->n, 4, 8) -
1667  11.9994372472037618) < eps,
1668  "Incorrect K at 4, 8");
1669  mu_assert(fabs(matrix_get(K, data->n, 4, 9) -
1670  8.6300134557803005) < eps,
1671  "Incorrect K at 4, 9");
1672  mu_assert(fabs(matrix_get(K, data->n, 5, 0) -
1673  13.4376986903046944) < eps,
1674  "Incorrect K at 5, 0");
1675  mu_assert(fabs(matrix_get(K, data->n, 5, 1) -
1676  11.9338476573364556) < eps,
1677  "Incorrect K at 5, 1");
1678  mu_assert(fabs(matrix_get(K, data->n, 5, 2) -
1679  7.4311529847899962) < eps,
1680  "Incorrect K at 5, 2");
1681  mu_assert(fabs(matrix_get(K, data->n, 5, 3) -
1682  12.2952603928598840) < eps,
1683  "Incorrect K at 5, 3");
1684  mu_assert(fabs(matrix_get(K, data->n, 5, 4) -
1685  8.9267358166744923) < eps,
1686  "Incorrect K at 5, 4");
1687  mu_assert(fabs(matrix_get(K, data->n, 5, 5) -
1688  13.3667509754465605) < eps,
1689  "Incorrect K at 5, 5");
1690  mu_assert(fabs(matrix_get(K, data->n, 5, 6) -
1691  9.2374362113086974) < eps,
1692  "Incorrect K at 5, 6");
1693  mu_assert(fabs(matrix_get(K, data->n, 5, 7) -
1694  12.3359255360486753) < eps,
1695  "Incorrect K at 5, 7");
1696  mu_assert(fabs(matrix_get(K, data->n, 5, 8) -
1697  11.2365407617438784) < eps,
1698  "Incorrect K at 5, 8");
1699  mu_assert(fabs(matrix_get(K, data->n, 5, 9) -
1700  10.0736132325944858) < eps,
1701  "Incorrect K at 5, 9");
1702  mu_assert(fabs(matrix_get(K, data->n, 6, 0) -
1703  11.2170859716846412) < eps,
1704  "Incorrect K at 6, 0");
1705  mu_assert(fabs(matrix_get(K, data->n, 6, 1) -
1706  12.8317520536684597) < eps,
1707  "Incorrect K at 6, 1");
1708  mu_assert(fabs(matrix_get(K, data->n, 6, 2) -
1709  9.8317460227342295) < eps,
1710  "Incorrect K at 6, 2");
1711  mu_assert(fabs(matrix_get(K, data->n, 6, 3) -
1712  12.5864308488164252) < eps,
1713  "Incorrect K at 6, 3");
1714  mu_assert(fabs(matrix_get(K, data->n, 6, 4) -
1715  12.6168065443066961) < eps,
1716  "Incorrect K at 6, 4");
1717  mu_assert(fabs(matrix_get(K, data->n, 6, 5) -
1718  9.2374362113086974) < eps,
1719  "Incorrect K at 6, 5");
1720  mu_assert(fabs(matrix_get(K, data->n, 6, 6) -
1721  12.5482922903136540) < eps,
1722  "Incorrect K at 6, 6");
1723  mu_assert(fabs(matrix_get(K, data->n, 6, 7) -
1724  9.8694581744218173) < eps,
1725  "Incorrect K at 6, 7");
1726  mu_assert(fabs(matrix_get(K, data->n, 6, 8) -
1727  11.9652582335280364) < eps,
1728  "Incorrect K at 6, 8");
1729  mu_assert(fabs(matrix_get(K, data->n, 6, 9) -
1730  8.7166346335015064) < eps,
1731  "Incorrect K at 6, 9");
1732  mu_assert(fabs(matrix_get(K, data->n, 7, 0) -
1733  11.8649726239060982) < eps,
1734  "Incorrect K at 7, 0");
1735  mu_assert(fabs(matrix_get(K, data->n, 7, 1) -
1736  10.1728085503000116) < eps,
1737  "Incorrect K at 7, 1");
1738  mu_assert(fabs(matrix_get(K, data->n, 7, 2) -
1739  7.5616330506213130) < eps,
1740  "Incorrect K at 7, 2");
1741  mu_assert(fabs(matrix_get(K, data->n, 7, 3) -
1742  13.5095269679848702) < eps,
1743  "Incorrect K at 7, 3");
1744  mu_assert(fabs(matrix_get(K, data->n, 7, 4) -
1745  9.7796024413467819) < eps,
1746  "Incorrect K at 7, 4");
1747  mu_assert(fabs(matrix_get(K, data->n, 7, 5) -
1748  12.3359255360486753) < eps,
1749  "Incorrect K at 7, 5");
1750  mu_assert(fabs(matrix_get(K, data->n, 7, 6) -
1751  9.8694581744218173) < eps,
1752  "Incorrect K at 7, 6");
1753  mu_assert(fabs(matrix_get(K, data->n, 7, 7) -
1754  12.9524293684505221) < eps,
1755  "Incorrect K at 7, 7");
1756  mu_assert(fabs(matrix_get(K, data->n, 7, 8) -
1757  12.3355075975696309) < eps,
1758  "Incorrect K at 7, 8");
1759  mu_assert(fabs(matrix_get(K, data->n, 7, 9) -
1760  10.1132148127652659) < eps,
1761  "Incorrect K at 7, 9");
1762  mu_assert(fabs(matrix_get(K, data->n, 8, 0) -
1763  11.9910642907247134) < eps,
1764  "Incorrect K at 8, 0");
1765  mu_assert(fabs(matrix_get(K, data->n, 8, 1) -
1766  11.7519359337010130) < eps,
1767  "Incorrect K at 8, 1");
1768  mu_assert(fabs(matrix_get(K, data->n, 8, 2) -
1769  8.8935156801233308) < eps,
1770  "Incorrect K at 8, 2");
1771  mu_assert(fabs(matrix_get(K, data->n, 8, 3) -
1772  14.4248904770779447) < eps,
1773  "Incorrect K at 8, 3");
1774  mu_assert(fabs(matrix_get(K, data->n, 8, 4) -
1775  11.9994372472037618) < eps,
1776  "Incorrect K at 8, 4");
1777  mu_assert(fabs(matrix_get(K, data->n, 8, 5) -
1778  11.2365407617438784) < eps,
1779  "Incorrect K at 8, 5");
1780  mu_assert(fabs(matrix_get(K, data->n, 8, 6) -
1781  11.9652582335280364) < eps,
1782  "Incorrect K at 8, 6");
1783  mu_assert(fabs(matrix_get(K, data->n, 8, 7) -
1784  12.3355075975696309) < eps,
1785  "Incorrect K at 8, 7");
1786  mu_assert(fabs(matrix_get(K, data->n, 8, 8) -
1787  13.3150520649955109) < eps,
1788  "Incorrect K at 8, 8");
1789  mu_assert(fabs(matrix_get(K, data->n, 8, 9) -
1790  9.8405270375666198) < eps,
1791  "Incorrect K at 8, 9");
1792  mu_assert(fabs(matrix_get(K, data->n, 9, 0) -
1793  10.0579319882111839) < eps,
1794  "Incorrect K at 9, 0");
1795  mu_assert(fabs(matrix_get(K, data->n, 9, 1) -
1796  9.3372389753548415) < eps,
1797  "Incorrect K at 9, 1");
1798  mu_assert(fabs(matrix_get(K, data->n, 9, 2) -
1799  7.4623650201501697) < eps,
1800  "Incorrect K at 9, 2");
1801  mu_assert(fabs(matrix_get(K, data->n, 9, 3) -
1802  10.4303067289663023) < eps,
1803  "Incorrect K at 9, 3");
1804  mu_assert(fabs(matrix_get(K, data->n, 9, 4) -
1805  8.6300134557803005) < eps,
1806  "Incorrect K at 9, 4");
1807  mu_assert(fabs(matrix_get(K, data->n, 9, 5) -
1808  10.0736132325944858) < eps,
1809  "Incorrect K at 9, 5");
1810  mu_assert(fabs(matrix_get(K, data->n, 9, 6) -
1811  8.7166346335015064) < eps,
1812  "Incorrect K at 9, 6");
1813  mu_assert(fabs(matrix_get(K, data->n, 9, 7) -
1814  10.1132148127652659) < eps,
1815  "Incorrect K at 9, 7");
1816  mu_assert(fabs(matrix_get(K, data->n, 9, 8) -
1817  9.8405270375666198) < eps,
1818  "Incorrect K at 9, 8");
1819  mu_assert(fabs(matrix_get(K, data->n, 9, 9) -
1820  8.7441654683119356) < eps,
1821  "Incorrect K at 9, 9");
1822  // end test code //
1823 
1824  free(K);
1825  gensvm_free_data(data);
1826  gensvm_free_model(model);
1827 
1828  return NULL;
1829 }
1830 
1831 char *test_kernel_compute_sigmoid()
1832 {
1833  struct GenModel *model = gensvm_init_model();
1834  struct GenData *data = gensvm_init_data();
1835 
1836  // setup //
1837  data->n = 10;
1838  data->m = 3;
1839  data->RAW = Calloc(double, data->n * (data->m + 1));
1840 
1841  model->n = 10;
1842  model->m = 3;
1843  model->kerneltype = K_SIGMOID;
1844  model->gamma = 1.23;
1845  model->coef = 1.6;
1846 
1847  double *K = Calloc(double, data->n * data->n);
1848 
1849  matrix_set(data->RAW, data->m+1, 0, 0, 1.0);
1850  matrix_set(data->RAW, data->m+1, 0, 1, 0.8056271362589000);
1851  matrix_set(data->RAW, data->m+1, 0, 2, 0.4874175854113872);
1852  matrix_set(data->RAW, data->m+1, 0, 3, 0.4453015882771756);
1853  matrix_set(data->RAW, data->m+1, 1, 0, 1.0);
1854  matrix_set(data->RAW, data->m+1, 1, 1, 0.7940590105180981);
1855  matrix_set(data->RAW, data->m+1, 1, 2, 0.1861049005485224);
1856  matrix_set(data->RAW, data->m+1, 1, 3, 0.8469394287449229);
1857  matrix_set(data->RAW, data->m+1, 2, 0, 1.0);
1858  matrix_set(data->RAW, data->m+1, 2, 1, 0.0294257611061681);
1859  matrix_set(data->RAW, data->m+1, 2, 2, 0.0242717976065267);
1860  matrix_set(data->RAW, data->m+1, 2, 3, 0.5039128672814752);
1861  matrix_set(data->RAW, data->m+1, 3, 0, 1.0);
1862  matrix_set(data->RAW, data->m+1, 3, 1, 0.1746563833537603);
1863  matrix_set(data->RAW, data->m+1, 3, 2, 0.9135736087631979);
1864  matrix_set(data->RAW, data->m+1, 3, 3, 0.5270258081021366);
1865  matrix_set(data->RAW, data->m+1, 4, 0, 1.0);
1866  matrix_set(data->RAW, data->m+1, 4, 1, 0.0022298761599785);
1867  matrix_set(data->RAW, data->m+1, 4, 2, 0.3773482059713607);
1868  matrix_set(data->RAW, data->m+1, 4, 3, 0.8009654729622842);
1869  matrix_set(data->RAW, data->m+1, 5, 0, 1.0);
1870  matrix_set(data->RAW, data->m+1, 5, 1, 0.6638830667081945);
1871  matrix_set(data->RAW, data->m+1, 5, 2, 0.6467607601353914);
1872  matrix_set(data->RAW, data->m+1, 5, 3, 0.0434948735457108);
1873  matrix_set(data->RAW, data->m+1, 6, 0, 1.0);
1874  matrix_set(data->RAW, data->m+1, 6, 1, 0.0770493004546461);
1875  matrix_set(data->RAW, data->m+1, 6, 2, 0.3699566427075194);
1876  matrix_set(data->RAW, data->m+1, 6, 3, 0.7863539761080217);
1877  matrix_set(data->RAW, data->m+1, 7, 0, 1.0);
1878  matrix_set(data->RAW, data->m+1, 7, 1, 0.2685233952731509);
1879  matrix_set(data->RAW, data->m+1, 7, 2, 0.8539966432782011);
1880  matrix_set(data->RAW, data->m+1, 7, 3, 0.0967159557826836);
1881  matrix_set(data->RAW, data->m+1, 8, 0, 1.0);
1882  matrix_set(data->RAW, data->m+1, 8, 1, 0.1163951898554611);
1883  matrix_set(data->RAW, data->m+1, 8, 2, 0.7667861436369238);
1884  matrix_set(data->RAW, data->m+1, 8, 3, 0.5031912600213351);
1885  matrix_set(data->RAW, data->m+1, 9, 0, 1.0);
1886  matrix_set(data->RAW, data->m+1, 9, 1, 0.2290251898688216);
1887  matrix_set(data->RAW, data->m+1, 9, 2, 0.4401981048538806);
1888  matrix_set(data->RAW, data->m+1, 9, 3, 0.0884616753393881);
1889 
1890  // end setup //
1891 
1892  // start test code //
1893  double eps = 1e-14;
1894  gensvm_kernel_compute(model, data, K);
1895 
1896  mu_assert(fabs(matrix_get(K, data->n, 0, 0) -
1897  0.9943637704548856) < eps,
1898  "Incorrect K at 0, 0");
1899  mu_assert(fabs(matrix_get(K, data->n, 0, 1) -
1900  0.9946686121177555) < eps,
1901  "Incorrect K at 0, 1");
1902  mu_assert(fabs(matrix_get(K, data->n, 0, 2) -
1903  0.9578937155783831) < eps,
1904  "Incorrect K at 0, 2");
1905  mu_assert(fabs(matrix_get(K, data->n, 0, 3) -
1906  0.9892315762620929) < eps,
1907  "Incorrect K at 0, 3");
1908  mu_assert(fabs(matrix_get(K, data->n, 0, 4) -
1909  0.9787589339778296) < eps,
1910  "Incorrect K at 0, 4");
1911  mu_assert(fabs(matrix_get(K, data->n, 0, 5) -
1912  0.9904431525124753) < eps,
1913  "Incorrect K at 0, 5");
1914  mu_assert(fabs(matrix_get(K, data->n, 0, 6) -
1915  0.9812018448276493) < eps,
1916  "Incorrect K at 0, 6");
1917  mu_assert(fabs(matrix_get(K, data->n, 0, 7) -
1918  0.9846502712939124) < eps,
1919  "Incorrect K at 0, 7");
1920  mu_assert(fabs(matrix_get(K, data->n, 0, 8) -
1921  0.9852360775152181) < eps,
1922  "Incorrect K at 0, 8");
1923  mu_assert(fabs(matrix_get(K, data->n, 0, 9) -
1924  0.9726553489464377) < eps,
1925  "Incorrect K at 0, 9");
1926  mu_assert(fabs(matrix_get(K, data->n, 1, 0) -
1927  0.9946686121177555) < eps,
1928  "Incorrect K at 1, 0");
1929  mu_assert(fabs(matrix_get(K, data->n, 1, 1) -
1930  0.9972853441139281) < eps,
1931  "Incorrect K at 1, 1");
1932  mu_assert(fabs(matrix_get(K, data->n, 1, 2) -
1933  0.9737099505662699) < eps,
1934  "Incorrect K at 1, 2");
1935  mu_assert(fabs(matrix_get(K, data->n, 1, 3) -
1936  0.9873570938969980) < eps,
1937  "Incorrect K at 1, 3");
1938  mu_assert(fabs(matrix_get(K, data->n, 1, 4) -
1939  0.9872109867697908) < eps,
1940  "Incorrect K at 1, 4");
1941  mu_assert(fabs(matrix_get(K, data->n, 1, 5) -
1942  0.9849733935382557) < eps,
1943  "Incorrect K at 1, 5");
1944  mu_assert(fabs(matrix_get(K, data->n, 1, 6) -
1945  0.9885619953841569) < eps,
1946  "Incorrect K at 1, 6");
1947  mu_assert(fabs(matrix_get(K, data->n, 1, 7) -
1948  0.9736717805509784) < eps,
1949  "Incorrect K at 1, 7");
1950  mu_assert(fabs(matrix_get(K, data->n, 1, 8) -
1951  0.9841030912139471) < eps,
1952  "Incorrect K at 1, 8");
1953  mu_assert(fabs(matrix_get(K, data->n, 1, 9) -
1954  0.9651822304880787) < eps,
1955  "Incorrect K at 1, 9");
1956  mu_assert(fabs(matrix_get(K, data->n, 2, 0) -
1957  0.9578937155783831) < eps,
1958  "Incorrect K at 2, 0");
1959  mu_assert(fabs(matrix_get(K, data->n, 2, 1) -
1960  0.9737099505662699) < eps,
1961  "Incorrect K at 2, 1");
1962  mu_assert(fabs(matrix_get(K, data->n, 2, 2) -
1963  0.9574301966133943) < eps,
1964  "Incorrect K at 2, 2");
1965  mu_assert(fabs(matrix_get(K, data->n, 2, 3) -
1966  0.9611091259460700) < eps,
1967  "Incorrect K at 2, 3");
1968  mu_assert(fabs(matrix_get(K, data->n, 2, 4) -
1969  0.9709023602232207) < eps,
1970  "Incorrect K at 2, 4");
1971  mu_assert(fabs(matrix_get(K, data->n, 2, 5) -
1972  0.9315907625390656) < eps,
1973  "Incorrect K at 2, 5");
1974  mu_assert(fabs(matrix_get(K, data->n, 2, 6) -
1975  0.9705232203974647) < eps,
1976  "Incorrect K at 2, 6");
1977  mu_assert(fabs(matrix_get(K, data->n, 2, 7) -
1978  0.9348012913572012) < eps,
1979  "Incorrect K at 2, 7");
1980  mu_assert(fabs(matrix_get(K, data->n, 2, 8) -
1981  0.9594537644613513) < eps,
1982  "Incorrect K at 2, 8");
1983  mu_assert(fabs(matrix_get(K, data->n, 2, 9) -
1984  0.9323746182879774) < eps,
1985  "Incorrect K at 2, 9");
1986  mu_assert(fabs(matrix_get(K, data->n, 3, 0) -
1987  0.9892315762620929) < eps,
1988  "Incorrect K at 3, 0");
1989  mu_assert(fabs(matrix_get(K, data->n, 3, 1) -
1990  0.9873570938969980) < eps,
1991  "Incorrect K at 3, 1");
1992  mu_assert(fabs(matrix_get(K, data->n, 3, 2) -
1993  0.9611091259460700) < eps,
1994  "Incorrect K at 3, 2");
1995  mu_assert(fabs(matrix_get(K, data->n, 3, 3) -
1996  0.9951110594420507) < eps,
1997  "Incorrect K at 3, 3");
1998  mu_assert(fabs(matrix_get(K, data->n, 3, 4) -
1999  0.9877282227805176) < eps,
2000  "Incorrect K at 3, 4");
2001  mu_assert(fabs(matrix_get(K, data->n, 3, 5) -
2002  0.9865497273302540) < eps,
2003  "Incorrect K at 3, 5");
2004  mu_assert(fabs(matrix_get(K, data->n, 3, 6) -
2005  0.9876865775961812) < eps,
2006  "Incorrect K at 3, 6");
2007  mu_assert(fabs(matrix_get(K, data->n, 3, 7) -
2008  0.9906424333748519) < eps,
2009  "Incorrect K at 3, 7");
2010  mu_assert(fabs(matrix_get(K, data->n, 3, 8) -
2011  0.9928175000327435) < eps,
2012  "Incorrect K at 3, 8");
2013  mu_assert(fabs(matrix_get(K, data->n, 3, 9) -
2014  0.9758002897316713) < eps,
2015  "Incorrect K at 3, 9");
2016  mu_assert(fabs(matrix_get(K, data->n, 4, 0) -
2017  0.9787589339778296) < eps,
2018  "Incorrect K at 4, 0");
2019  mu_assert(fabs(matrix_get(K, data->n, 4, 1) -
2020  0.9872109867697908) < eps,
2021  "Incorrect K at 4, 1");
2022  mu_assert(fabs(matrix_get(K, data->n, 4, 2) -
2023  0.9709023602232207) < eps,
2024  "Incorrect K at 4, 2");
2025  mu_assert(fabs(matrix_get(K, data->n, 4, 3) -
2026  0.9877282227805176) < eps,
2027  "Incorrect K at 4, 3");
2028  mu_assert(fabs(matrix_get(K, data->n, 4, 4) -
2029  0.9882189022474748) < eps,
2030  "Incorrect K at 4, 4");
2031  mu_assert(fabs(matrix_get(K, data->n, 4, 5) -
2032  0.9599174207778631) < eps,
2033  "Incorrect K at 4, 5");
2034  mu_assert(fabs(matrix_get(K, data->n, 4, 6) -
2035  0.9877988987284404) < eps,
2036  "Incorrect K at 4, 6");
2037  mu_assert(fabs(matrix_get(K, data->n, 4, 7) -
2038  0.9700057126716283) < eps,
2039  "Incorrect K at 4, 7");
2040  mu_assert(fabs(matrix_get(K, data->n, 4, 8) -
2041  0.9852740882958205) < eps,
2042  "Incorrect K at 4, 8");
2043  mu_assert(fabs(matrix_get(K, data->n, 4, 9) -
2044  0.9555553363633501) < eps,
2045  "Incorrect K at 4, 9");
2046  mu_assert(fabs(matrix_get(K, data->n, 5, 0) -
2047  0.9904431525124753) < eps,
2048  "Incorrect K at 5, 0");
2049  mu_assert(fabs(matrix_get(K, data->n, 5, 1) -
2050  0.9849733935382557) < eps,
2051  "Incorrect K at 5, 1");
2052  mu_assert(fabs(matrix_get(K, data->n, 5, 2) -
2053  0.9315907625390656) < eps,
2054  "Incorrect K at 5, 2");
2055  mu_assert(fabs(matrix_get(K, data->n, 5, 3) -
2056  0.9865497273302540) < eps,
2057  "Incorrect K at 5, 3");
2058  mu_assert(fabs(matrix_get(K, data->n, 5, 4) -
2059  0.9599174207778631) < eps,
2060  "Incorrect K at 5, 4");
2061  mu_assert(fabs(matrix_get(K, data->n, 5, 5) -
2062  0.9902416959670991) < eps,
2063  "Incorrect K at 5, 5");
2064  mu_assert(fabs(matrix_get(K, data->n, 5, 6) -
2065  0.9639775155470058) < eps,
2066  "Incorrect K at 5, 6");
2067  mu_assert(fabs(matrix_get(K, data->n, 5, 7) -
2068  0.9867152808385368) < eps,
2069  "Incorrect K at 5, 7");
2070  mu_assert(fabs(matrix_get(K, data->n, 5, 8) -
2071  0.9813171680326727) < eps,
2072  "Incorrect K at 5, 8");
2073  mu_assert(fabs(matrix_get(K, data->n, 5, 9) -
2074  0.9727966479866800) < eps,
2075  "Incorrect K at 5, 9");
2076  mu_assert(fabs(matrix_get(K, data->n, 6, 0) -
2077  0.9812018448276493) < eps,
2078  "Incorrect K at 6, 0");
2079  mu_assert(fabs(matrix_get(K, data->n, 6, 1) -
2080  0.9885619953841569) < eps,
2081  "Incorrect K at 6, 1");
2082  mu_assert(fabs(matrix_get(K, data->n, 6, 2) -
2083  0.9705232203974647) < eps,
2084  "Incorrect K at 6, 2");
2085  mu_assert(fabs(matrix_get(K, data->n, 6, 3) -
2086  0.9876865775961812) < eps,
2087  "Incorrect K at 6, 3");
2088  mu_assert(fabs(matrix_get(K, data->n, 6, 4) -
2089  0.9877988987284404) < eps,
2090  "Incorrect K at 6, 4");
2091  mu_assert(fabs(matrix_get(K, data->n, 6, 5) -
2092  0.9639775155470058) < eps,
2093  "Incorrect K at 6, 5");
2094  mu_assert(fabs(matrix_get(K, data->n, 6, 6) -
2095  0.9875439243202984) < eps,
2096  "Incorrect K at 6, 6");
2097  mu_assert(fabs(matrix_get(K, data->n, 6, 7) -
2098  0.9708912767839261) < eps,
2099  "Incorrect K at 6, 7");
2100  mu_assert(fabs(matrix_get(K, data->n, 6, 8) -
2101  0.9851182379707764) < eps,
2102  "Incorrect K at 6, 8");
2103  mu_assert(fabs(matrix_get(K, data->n, 6, 9) -
2104  0.9568814495759891) < eps,
2105  "Incorrect K at 6, 9");
2106  mu_assert(fabs(matrix_get(K, data->n, 7, 0) -
2107  0.9846502712939124) < eps,
2108  "Incorrect K at 7, 0");
2109  mu_assert(fabs(matrix_get(K, data->n, 7, 1) -
2110  0.9736717805509784) < eps,
2111  "Incorrect K at 7, 1");
2112  mu_assert(fabs(matrix_get(K, data->n, 7, 2) -
2113  0.9348012913572012) < eps,
2114  "Incorrect K at 7, 2");
2115  mu_assert(fabs(matrix_get(K, data->n, 7, 3) -
2116  0.9906424333748519) < eps,
2117  "Incorrect K at 7, 3");
2118  mu_assert(fabs(matrix_get(K, data->n, 7, 4) -
2119  0.9700057126716283) < eps,
2120  "Incorrect K at 7, 4");
2121  mu_assert(fabs(matrix_get(K, data->n, 7, 5) -
2122  0.9867152808385368) < eps,
2123  "Incorrect K at 7, 5");
2124  mu_assert(fabs(matrix_get(K, data->n, 7, 6) -
2125  0.9708912767839261) < eps,
2126  "Incorrect K at 7, 6");
2127  mu_assert(fabs(matrix_get(K, data->n, 7, 7) -
2128  0.9889671313757883) < eps,
2129  "Incorrect K at 7, 7");
2130  mu_assert(fabs(matrix_get(K, data->n, 7, 8) -
2131  0.9867135908997623) < eps,
2132  "Incorrect K at 7, 8");
2133  mu_assert(fabs(matrix_get(K, data->n, 7, 9) -
2134  0.9731498666169363) < eps,
2135  "Incorrect K at 7, 9");
2136  mu_assert(fabs(matrix_get(K, data->n, 8, 0) -
2137  0.9852360775152181) < eps,
2138  "Incorrect K at 8, 0");
2139  mu_assert(fabs(matrix_get(K, data->n, 8, 1) -
2140  0.9841030912139471) < eps,
2141  "Incorrect K at 8, 1");
2142  mu_assert(fabs(matrix_get(K, data->n, 8, 2) -
2143  0.9594537644613513) < eps,
2144  "Incorrect K at 8, 2");
2145  mu_assert(fabs(matrix_get(K, data->n, 8, 3) -
2146  0.9928175000327435) < eps,
2147  "Incorrect K at 8, 3");
2148  mu_assert(fabs(matrix_get(K, data->n, 8, 4) -
2149  0.9852740882958205) < eps,
2150  "Incorrect K at 8, 4");
2151  mu_assert(fabs(matrix_get(K, data->n, 8, 5) -
2152  0.9813171680326727) < eps,
2153  "Incorrect K at 8, 5");
2154  mu_assert(fabs(matrix_get(K, data->n, 8, 6) -
2155  0.9851182379707764) < eps,
2156  "Incorrect K at 8, 6");
2157  mu_assert(fabs(matrix_get(K, data->n, 8, 7) -
2158  0.9867135908997623) < eps,
2159  "Incorrect K at 8, 7");
2160  mu_assert(fabs(matrix_get(K, data->n, 8, 8) -
2161  0.9900919372870961) < eps,
2162  "Incorrect K at 8, 8");
2163  mu_assert(fabs(matrix_get(K, data->n, 8, 9) -
2164  0.9706093824836438) < eps,
2165  "Incorrect K at 8, 9");
2166  mu_assert(fabs(matrix_get(K, data->n, 9, 0) -
2167  0.9726553489464377) < eps,
2168  "Incorrect K at 9, 0");
2169  mu_assert(fabs(matrix_get(K, data->n, 9, 1) -
2170  0.9651822304880787) < eps,
2171  "Incorrect K at 9, 1");
2172  mu_assert(fabs(matrix_get(K, data->n, 9, 2) -
2173  0.9323746182879774) < eps,
2174  "Incorrect K at 9, 2");
2175  mu_assert(fabs(matrix_get(K, data->n, 9, 3) -
2176  0.9758002897316713) < eps,
2177  "Incorrect K at 9, 3");
2178  mu_assert(fabs(matrix_get(K, data->n, 9, 4) -
2179  0.9555553363633501) < eps,
2180  "Incorrect K at 9, 4");
2181  mu_assert(fabs(matrix_get(K, data->n, 9, 5) -
2182  0.9727966479866800) < eps,
2183  "Incorrect K at 9, 5");
2184  mu_assert(fabs(matrix_get(K, data->n, 9, 6) -
2185  0.9568814495759891) < eps,
2186  "Incorrect K at 9, 6");
2187  mu_assert(fabs(matrix_get(K, data->n, 9, 7) -
2188  0.9731498666169363) < eps,
2189  "Incorrect K at 9, 7");
2190  mu_assert(fabs(matrix_get(K, data->n, 9, 8) -
2191  0.9706093824836438) < eps,
2192  "Incorrect K at 9, 8");
2193  mu_assert(fabs(matrix_get(K, data->n, 9, 9) -
2194  0.9572935857028608) < eps,
2195  "Incorrect K at 9, 9");
2196 
2197  // end test code //
2198 
2199  free(K);
2200  gensvm_free_data(data);
2201  gensvm_free_model(model);
2202 
2203  return NULL;
2204 }
2205 
2206 char *test_kernel_eigendecomp()
2207 {
2208  int n = 10;
2209  double *K = Calloc(double, n*n);
2210 
2211  matrix_set(K, n, 0, 0, 1.8957230074596658);
2212  matrix_set(K, n, 0, 1, 1.5788353939003679);
2213  matrix_set(K, n, 0, 2, 1.3341924479973508);
2214  matrix_set(K, n, 0, 3, 1.9135891286401130);
2215  matrix_set(K, n, 0, 4, 1.0234654124933122);
2216  matrix_set(K, n, 0, 5, 1.2788676188422881);
2217  matrix_set(K, n, 0, 6, 1.5231707888435004);
2218  matrix_set(K, n, 0, 7, 1.7650988656771305);
2219  matrix_set(K, n, 0, 8, 1.6565264972793248);
2220  matrix_set(K, n, 0, 9, 1.7720466624967910);
2221  matrix_set(K, n, 1, 0, 1.5788353939003679);
2222  matrix_set(K, n, 1, 1, 3.3160214905692085);
2223  matrix_set(K, n, 1, 2, 1.9970415315746892);
2224  matrix_set(K, n, 1, 3, 2.2818422166445553);
2225  matrix_set(K, n, 1, 4, 2.2552591311973780);
2226  matrix_set(K, n, 1, 5, 2.6229134325776573);
2227  matrix_set(K, n, 1, 6, 2.1715097610253036);
2228  matrix_set(K, n, 1, 7, 1.6910997290719514);
2229  matrix_set(K, n, 1, 8, 2.6386724572773361);
2230  matrix_set(K, n, 1, 9, 2.6587015780393881);
2231  matrix_set(K, n, 2, 0, 1.3341924479973508);
2232  matrix_set(K, n, 2, 1, 1.9970415315746892);
2233  matrix_set(K, n, 2, 2, 2.9794552376145154);
2234  matrix_set(K, n, 2, 3, 2.6421606833813742);
2235  matrix_set(K, n, 2, 4, 2.2526586210360087);
2236  matrix_set(K, n, 2, 5, 2.0022301831640106);
2237  matrix_set(K, n, 2, 6, 2.5890262336485397);
2238  matrix_set(K, n, 2, 7, 2.2391395202916926);
2239  matrix_set(K, n, 2, 8, 2.4893629764352507);
2240  matrix_set(K, n, 2, 9, 2.7339053828614057);
2241  matrix_set(K, n, 3, 0, 1.9135891286401130);
2242  matrix_set(K, n, 3, 1, 2.2818422166445553);
2243  matrix_set(K, n, 3, 2, 2.6421606833813742);
2244  matrix_set(K, n, 3, 3, 3.4991899582151325);
2245  matrix_set(K, n, 3, 4, 1.8812151717558272);
2246  matrix_set(K, n, 3, 5, 2.6296896695972061);
2247  matrix_set(K, n, 3, 6, 2.8161237364134410);
2248  matrix_set(K, n, 3, 7, 2.7729181198442641);
2249  matrix_set(K, n, 3, 8, 2.8241735649875288);
2250  matrix_set(K, n, 3, 9, 2.9235411206761861);
2251  matrix_set(K, n, 4, 0, 1.0234654124933122);
2252  matrix_set(K, n, 4, 1, 2.2552591311973780);
2253  matrix_set(K, n, 4, 2, 2.2526586210360087);
2254  matrix_set(K, n, 4, 3, 1.8812151717558272);
2255  matrix_set(K, n, 4, 4, 2.5093034717737615);
2256  matrix_set(K, n, 4, 5, 1.8901064622829966);
2257  matrix_set(K, n, 4, 6, 1.8736444909319021);
2258  matrix_set(K, n, 4, 7, 1.4654421216986091);
2259  matrix_set(K, n, 4, 8, 2.2618348136979898);
2260  matrix_set(K, n, 4, 9, 1.9853102751114591);
2261  matrix_set(K, n, 5, 0, 1.2788676188422881);
2262  matrix_set(K, n, 5, 1, 2.6229134325776573);
2263  matrix_set(K, n, 5, 2, 2.0022301831640106);
2264  matrix_set(K, n, 5, 3, 2.6296896695972061);
2265  matrix_set(K, n, 5, 4, 1.8901064622829966);
2266  matrix_set(K, n, 5, 5, 2.8486874970858160);
2267  matrix_set(K, n, 5, 6, 2.1833913326358250);
2268  matrix_set(K, n, 5, 7, 1.6103467044130788);
2269  matrix_set(K, n, 5, 8, 2.5103824469216467);
2270  matrix_set(K, n, 5, 9, 2.5894371939176293);
2271  matrix_set(K, n, 6, 0, 1.5231707888435004);
2272  matrix_set(K, n, 6, 1, 2.1715097610253036);
2273  matrix_set(K, n, 6, 2, 2.5890262336485397);
2274  matrix_set(K, n, 6, 3, 2.8161237364134410);
2275  matrix_set(K, n, 6, 4, 1.8736444909319021);
2276  matrix_set(K, n, 6, 5, 2.1833913326358250);
2277  matrix_set(K, n, 6, 6, 2.9754371323085365);
2278  matrix_set(K, n, 6, 7, 2.0569948157192495);
2279  matrix_set(K, n, 6, 8, 2.7702792216087251);
2280  matrix_set(K, n, 6, 9, 2.6955896898884357);
2281  matrix_set(K, n, 7, 0, 1.7650988656771305);
2282  matrix_set(K, n, 7, 1, 1.6910997290719514);
2283  matrix_set(K, n, 7, 2, 2.2391395202916926);
2284  matrix_set(K, n, 7, 3, 2.7729181198442641);
2285  matrix_set(K, n, 7, 4, 1.4654421216986091);
2286  matrix_set(K, n, 7, 5, 1.6103467044130788);
2287  matrix_set(K, n, 7, 6, 2.0569948157192495);
2288  matrix_set(K, n, 7, 7, 2.8491469863450520);
2289  matrix_set(K, n, 7, 8, 1.9828570918824218);
2290  matrix_set(K, n, 7, 9, 2.3284525338942448);
2291  matrix_set(K, n, 8, 0, 1.6565264972793248);
2292  matrix_set(K, n, 8, 1, 2.6386724572773361);
2293  matrix_set(K, n, 8, 2, 2.4893629764352507);
2294  matrix_set(K, n, 8, 3, 2.8241735649875288);
2295  matrix_set(K, n, 8, 4, 2.2618348136979898);
2296  matrix_set(K, n, 8, 5, 2.5103824469216467);
2297  matrix_set(K, n, 8, 6, 2.7702792216087251);
2298  matrix_set(K, n, 8, 7, 1.9828570918824218);
2299  matrix_set(K, n, 8, 8, 3.1036474712902948);
2300  matrix_set(K, n, 8, 9, 2.7267087162991572);
2301  matrix_set(K, n, 9, 0, 1.7720466624967910);
2302  matrix_set(K, n, 9, 1, 2.6587015780393881);
2303  matrix_set(K, n, 9, 2, 2.7339053828614057);
2304  matrix_set(K, n, 9, 3, 2.9235411206761861);
2305  matrix_set(K, n, 9, 4, 1.9853102751114591);
2306  matrix_set(K, n, 9, 5, 2.5894371939176293);
2307  matrix_set(K, n, 9, 6, 2.6955896898884357);
2308  matrix_set(K, n, 9, 7, 2.3284525338942448);
2309  matrix_set(K, n, 9, 8, 2.7267087162991572);
2310  matrix_set(K, n, 9, 9, 3.6481211298649119);
2311 
2312  // start test code //
2313  double *P = NULL;
2314  double *Sigma = NULL;
2315  long r = gensvm_kernel_eigendecomp(K, n, 1e-2, &P, &Sigma);
2316  double eps = 1e-13;
2317 
2318  mu_assert(r == 7, "Incorrect number of eigenvalues kept");
2319 
2320  // Note: to overcome sign variability in the eigenvectors, we take the
2321  // absolute value of the elements of P and the expected outcome.
2322 
2323  mu_assert(fabs(fabs(matrix_get(P, r, 0, 0)) -
2324  fabs(0.2153575812884510)) < eps,
2325  "Incorrect P at 0, 0");
2326  mu_assert(fabs(fabs(matrix_get(P, r, 0, 1)) -
2327  fabs(0.2745973925101974)) < eps,
2328  "Incorrect P at 0, 1");
2329  mu_assert(fabs(fabs(matrix_get(P, r, 0, 2)) -
2330  fabs(0.4550895791914591)) < eps,
2331  "Incorrect P at 0, 2");
2332  mu_assert(fabs(fabs(matrix_get(P, r, 0, 3)) -
2333  fabs(-0.3884421314028316)) < eps,
2334  "Incorrect P at 0, 3");
2335  mu_assert(fabs(fabs(matrix_get(P, r, 0, 4)) -
2336  fabs(0.1160315888082866)) < eps,
2337  "Incorrect P at 0, 4");
2338  mu_assert(fabs(fabs(matrix_get(P, r, 0, 5)) -
2339  fabs(0.4302035203307312)) < eps,
2340  "Incorrect P at 0, 5");
2341  mu_assert(fabs(fabs(matrix_get(P, r, 0, 6)) -
2342  fabs(-0.4669338527728559)) < eps,
2343  "Incorrect P at 0, 6");
2344  mu_assert(fabs(fabs(matrix_get(P, r, 1, 0)) -
2345  fabs(0.3217489710376946)) < eps,
2346  "Incorrect P at 1, 0");
2347  mu_assert(fabs(fabs(matrix_get(P, r, 1, 1)) -
2348  fabs(-0.4945822605094066)) < eps,
2349  "Incorrect P at 1, 1");
2350  mu_assert(fabs(fabs(matrix_get(P, r, 1, 2)) -
2351  fabs(0.3769753694343475)) < eps,
2352  "Incorrect P at 1, 2");
2353  mu_assert(fabs(fabs(matrix_get(P, r, 1, 3)) -
2354  fabs(-0.2972948635736606)) < eps,
2355  "Incorrect P at 1, 3");
2356  mu_assert(fabs(fabs(matrix_get(P, r, 1, 4)) -
2357  fabs(-0.1011097319500622)) < eps,
2358  "Incorrect P at 1, 4");
2359  mu_assert(fabs(fabs(matrix_get(P, r, 1, 5)) -
2360  fabs(0.0306004375001570)) < eps,
2361  "Incorrect P at 1, 5");
2362  mu_assert(fabs(fabs(matrix_get(P, r, 1, 6)) -
2363  fabs(0.5322704452300250)) < eps,
2364  "Incorrect P at 1, 6");
2365  mu_assert(fabs(fabs(matrix_get(P, r, 2, 0)) -
2366  fabs(0.3239269538650612)) < eps,
2367  "Incorrect P at 2, 0");
2368  mu_assert(fabs(fabs(matrix_get(P, r, 2, 1)) -
2369  fabs(0.1131046585105233)) < eps,
2370  "Incorrect P at 2, 1");
2371  mu_assert(fabs(fabs(matrix_get(P, r, 2, 2)) -
2372  fabs(-0.5683419560926302)) < eps,
2373  "Incorrect P at 2, 2");
2374  mu_assert(fabs(fabs(matrix_get(P, r, 2, 3)) -
2375  fabs(-0.0566442945574068)) < eps,
2376  "Incorrect P at 2, 3");
2377  mu_assert(fabs(fabs(matrix_get(P, r, 2, 4)) -
2378  fabs(-0.2195800248661894)) < eps,
2379  "Incorrect P at 2, 4");
2380  mu_assert(fabs(fabs(matrix_get(P, r, 2, 5)) -
2381  fabs(-0.0120101816760300)) < eps,
2382  "Incorrect P at 2, 5");
2383  mu_assert(fabs(fabs(matrix_get(P, r, 2, 6)) -
2384  fabs(-0.0868590923278641)) < eps,
2385  "Incorrect P at 2, 6");
2386  mu_assert(fabs(fabs(matrix_get(P, r, 3, 0)) -
2387  fabs(0.3643049297817086)) < eps,
2388  "Incorrect P at 3, 0");
2389  mu_assert(fabs(fabs(matrix_get(P, r, 3, 1)) -
2390  fabs(0.3137060295518203)) < eps,
2391  "Incorrect P at 3, 1");
2392  mu_assert(fabs(fabs(matrix_get(P, r, 3, 2)) -
2393  fabs(0.1059271459195730)) < eps,
2394  "Incorrect P at 3, 2");
2395  mu_assert(fabs(fabs(matrix_get(P, r, 3, 3)) -
2396  fabs(0.2260527473443755)) < eps,
2397  "Incorrect P at 3, 3");
2398  mu_assert(fabs(fabs(matrix_get(P, r, 3, 4)) -
2399  fabs(0.2873469240341838)) < eps,
2400  "Incorrect P at 3, 4");
2401  mu_assert(fabs(fabs(matrix_get(P, r, 3, 5)) -
2402  fabs(-0.3577074997001115)) < eps,
2403  "Incorrect P at 3, 5");
2404  mu_assert(fabs(fabs(matrix_get(P, r, 3, 6)) -
2405  fabs(-0.1176008886950781)) < eps,
2406  "Incorrect P at 3, 6");
2407  mu_assert(fabs(fabs(matrix_get(P, r, 4, 0)) -
2408  fabs(0.2685490754867729)) < eps,
2409  "Incorrect P at 4, 0");
2410  mu_assert(fabs(fabs(matrix_get(P, r, 4, 1)) -
2411  fabs(-0.3602884322676240)) < eps,
2412  "Incorrect P at 4, 1");
2413  mu_assert(fabs(fabs(matrix_get(P, r, 4, 2)) -
2414  fabs(-0.4208535241232802)) < eps,
2415  "Incorrect P at 4, 2");
2416  mu_assert(fabs(fabs(matrix_get(P, r, 4, 3)) -
2417  fabs(-0.5004289581783992)) < eps,
2418  "Incorrect P at 4, 3");
2419  mu_assert(fabs(fabs(matrix_get(P, r, 4, 4)) -
2420  fabs(0.0581201143184524)) < eps,
2421  "Incorrect P at 4, 4");
2422  mu_assert(fabs(fabs(matrix_get(P, r, 4, 5)) -
2423  fabs(-0.1560533086067875)) < eps,
2424  "Incorrect P at 4, 5");
2425  mu_assert(fabs(fabs(matrix_get(P, r, 4, 6)) -
2426  fabs(-0.2808692440831040)) < eps,
2427  "Incorrect P at 4, 6");
2428  mu_assert(fabs(fabs(matrix_get(P, r, 5, 0)) -
2429  fabs(0.3097165272244328)) < eps,
2430  "Incorrect P at 5, 0");
2431  mu_assert(fabs(fabs(matrix_get(P, r, 5, 1)) -
2432  fabs(-0.3150295049924597)) < eps,
2433  "Incorrect P at 5, 1");
2434  mu_assert(fabs(fabs(matrix_get(P, r, 5, 2)) -
2435  fabs(0.2661795640562757)) < eps,
2436  "Incorrect P at 5, 2");
2437  mu_assert(fabs(fabs(matrix_get(P, r, 5, 3)) -
2438  fabs(0.3687999410293836)) < eps,
2439  "Incorrect P at 5, 3");
2440  mu_assert(fabs(fabs(matrix_get(P, r, 5, 4)) -
2441  fabs(0.0756501054032381)) < eps,
2442  "Incorrect P at 5, 4");
2443  mu_assert(fabs(fabs(matrix_get(P, r, 5, 5)) -
2444  fabs(-0.4702905504198338)) < eps,
2445  "Incorrect P at 5, 5");
2446  mu_assert(fabs(fabs(matrix_get(P, r, 5, 6)) -
2447  fabs(-0.2502907081561355)) < eps,
2448  "Incorrect P at 5, 6");
2449  mu_assert(fabs(fabs(matrix_get(P, r, 6, 0)) -
2450  fabs(0.3303343184191819)) < eps,
2451  "Incorrect P at 6, 0");
2452  mu_assert(fabs(fabs(matrix_get(P, r, 6, 1)) -
2453  fabs(0.0877791634967746)) < eps,
2454  "Incorrect P at 6, 1");
2455  mu_assert(fabs(fabs(matrix_get(P, r, 6, 2)) -
2456  fabs(-0.2291903024112904)) < eps,
2457  "Incorrect P at 6, 2");
2458  mu_assert(fabs(fabs(matrix_get(P, r, 6, 3)) -
2459  fabs(0.3378230216485225)) < eps,
2460  "Incorrect P at 6, 3");
2461  mu_assert(fabs(fabs(matrix_get(P, r, 6, 4)) -
2462  fabs(0.2813505143218815)) < eps,
2463  "Incorrect P at 6, 4");
2464  mu_assert(fabs(fabs(matrix_get(P, r, 6, 5)) -
2465  fabs(0.4390481386320075)) < eps,
2466  "Incorrect P at 6, 5");
2467  mu_assert(fabs(fabs(matrix_get(P, r, 6, 6)) -
2468  fabs(0.3960648555497706)) < eps,
2469  "Incorrect P at 6, 6");
2470  mu_assert(fabs(fabs(matrix_get(P, r, 7, 0)) -
2471  fabs(0.2867008390424503)) < eps,
2472  "Incorrect P at 7, 0");
2473  mu_assert(fabs(fabs(matrix_get(P, r, 7, 1)) -
2474  fabs(0.5529782699385689)) < eps,
2475  "Incorrect P at 7, 1");
2476  mu_assert(fabs(fabs(matrix_get(P, r, 7, 2)) -
2477  fabs(0.0595354369281301)) < eps,
2478  "Incorrect P at 7, 2");
2479  mu_assert(fabs(fabs(matrix_get(P, r, 7, 3)) -
2480  fabs(-0.3535615166878320)) < eps,
2481  "Incorrect P at 7, 3");
2482  mu_assert(fabs(fabs(matrix_get(P, r, 7, 4)) -
2483  fabs(-0.0706307412848860)) < eps,
2484  "Incorrect P at 7, 4");
2485  mu_assert(fabs(fabs(matrix_get(P, r, 7, 5)) -
2486  fabs(-0.3515408303354066)) < eps,
2487  "Incorrect P at 7, 5");
2488  mu_assert(fabs(fabs(matrix_get(P, r, 7, 6)) -
2489  fabs(0.3840483694579672)) < eps,
2490  "Incorrect P at 7, 6");
2491  mu_assert(fabs(fabs(matrix_get(P, r, 8, 0)) -
2492  fabs(0.3474605686018905)) < eps,
2493  "Incorrect P at 8, 0");
2494  mu_assert(fabs(fabs(matrix_get(P, r, 8, 1)) -
2495  fabs(-0.1590687116733123)) < eps,
2496  "Incorrect P at 8, 1");
2497  mu_assert(fabs(fabs(matrix_get(P, r, 8, 2)) -
2498  fabs(-0.0565892834229501)) < eps,
2499  "Incorrect P at 8, 2");
2500  mu_assert(fabs(fabs(matrix_get(P, r, 8, 3)) -
2501  fabs(0.0725995550169575)) < eps,
2502  "Incorrect P at 8, 3");
2503  mu_assert(fabs(fabs(matrix_get(P, r, 8, 4)) -
2504  fabs(0.4060731268950495)) < eps,
2505  "Incorrect P at 8, 4");
2506  mu_assert(fabs(fabs(matrix_get(P, r, 8, 5)) -
2507  fabs(0.2797250817800897)) < eps,
2508  "Incorrect P at 8, 5");
2509  mu_assert(fabs(fabs(matrix_get(P, r, 8, 6)) -
2510  fabs(-0.0976363581213828)) < eps,
2511  "Incorrect P at 8, 6");
2512  mu_assert(fabs(fabs(matrix_get(P, r, 9, 0)) -
2513  fabs(0.3638159501275298)) < eps,
2514  "Incorrect P at 9, 0");
2515  mu_assert(fabs(fabs(matrix_get(P, r, 9, 1)) -
2516  fabs(0.0305969903511121)) < eps,
2517  "Incorrect P at 9, 1");
2518  mu_assert(fabs(fabs(matrix_get(P, r, 9, 2)) -
2519  fabs(0.0964657835567429)) < eps,
2520  "Incorrect P at 9, 2");
2521  mu_assert(fabs(fabs(matrix_get(P, r, 9, 3)) -
2522  fabs(0.2749121311297592)) < eps,
2523  "Incorrect P at 9, 3");
2524  mu_assert(fabs(fabs(matrix_get(P, r, 9, 4)) -
2525  fabs(-0.7664116168127906)) < eps,
2526  "Incorrect P at 9, 4");
2527  mu_assert(fabs(fabs(matrix_get(P, r, 9, 5)) -
2528  fabs(0.2139473364333364)) < eps,
2529  "Incorrect P at 9, 5");
2530  mu_assert(fabs(fabs(matrix_get(P, r, 9, 6)) -
2531  fabs(-0.1478517167777606)) < eps,
2532  "Incorrect P at 9, 6");
2533 
2534  eps = 1e-13;
2535  mu_assert(fabs(Sigma[0] - 22.9663721202447704) < eps,
2536  "Incorrect Sigma at 0");
2537  mu_assert(fabs(Sigma[1] - 2.2569857335186856) < eps,
2538  "Incorrect Sigma at 1");
2539  mu_assert(fabs(Sigma[2] - 1.4177404640754938) < eps,
2540  "Incorrect Sigma at 2");
2541  mu_assert(fabs(Sigma[3] - 1.0075496644459232) < eps,
2542  "Incorrect Sigma at 3");
2543  mu_assert(fabs(Sigma[4] - 0.7919296491505164) < eps,
2544  "Incorrect Sigma at 4");
2545  mu_assert(fabs(Sigma[5] - 0.6808726728950240) < eps,
2546  "Incorrect Sigma at 5");
2547  mu_assert(fabs(Sigma[6] - 0.2909718164349679) < eps,
2548  "Incorrect Sigma at 6");
2549 
2550  // end test code //
2551 
2552  free(K);
2553  free(P);
2554  free(Sigma);
2555 
2556  return NULL;
2557 }
2558 
2559 char *test_kernel_cross_rbf()
2560 {
2561  struct GenModel *model = gensvm_init_model();
2562  struct GenData *data_1 = gensvm_init_data();
2563  struct GenData *data_2 = gensvm_init_data();
2564 
2565  // setup //
2566  data_1->n = 10;
2567  data_1->m = 3;
2568  data_1->RAW = Calloc(double, data_1->n * (data_1->m + 1));
2569 
2570  data_2->n = 5;
2571  data_2->m = 3;
2572  data_2->RAW = Calloc(double, data_2->n * (data_2->m + 1));
2573 
2574  model->n = 10;
2575  model->m = 3;
2576  model->kerneltype = K_RBF;
2577  model->gamma = 0.348;
2578 
2579  matrix_set(data_1->RAW, data_1->m+1, 0, 0, 1.0000000000000000);
2580  matrix_set(data_1->RAW, data_1->m+1, 0, 1, 0.8056271362589000);
2581  matrix_set(data_1->RAW, data_1->m+1, 0, 2, 0.4874175854113872);
2582  matrix_set(data_1->RAW, data_1->m+1, 0, 3, 0.4453015882771756);
2583  matrix_set(data_1->RAW, data_1->m+1, 1, 0, 1.0000000000000000);
2584  matrix_set(data_1->RAW, data_1->m+1, 1, 1, 0.7940590105180981);
2585  matrix_set(data_1->RAW, data_1->m+1, 1, 2, 0.1861049005485224);
2586  matrix_set(data_1->RAW, data_1->m+1, 1, 3, 0.8469394287449229);
2587  matrix_set(data_1->RAW, data_1->m+1, 2, 0, 1.0000000000000000);
2588  matrix_set(data_1->RAW, data_1->m+1, 2, 1, 0.0294257611061681);
2589  matrix_set(data_1->RAW, data_1->m+1, 2, 2, 0.0242717976065267);
2590  matrix_set(data_1->RAW, data_1->m+1, 2, 3, 0.5039128672814752);
2591  matrix_set(data_1->RAW, data_1->m+1, 3, 0, 1.0000000000000000);
2592  matrix_set(data_1->RAW, data_1->m+1, 3, 1, 0.1746563833537603);
2593  matrix_set(data_1->RAW, data_1->m+1, 3, 2, 0.9135736087631979);
2594  matrix_set(data_1->RAW, data_1->m+1, 3, 3, 0.5270258081021366);
2595  matrix_set(data_1->RAW, data_1->m+1, 4, 0, 1.0000000000000000);
2596  matrix_set(data_1->RAW, data_1->m+1, 4, 1, 0.0022298761599785);
2597  matrix_set(data_1->RAW, data_1->m+1, 4, 2, 0.3773482059713607);
2598  matrix_set(data_1->RAW, data_1->m+1, 4, 3, 0.8009654729622842);
2599  matrix_set(data_1->RAW, data_1->m+1, 5, 0, 1.0000000000000000);
2600  matrix_set(data_1->RAW, data_1->m+1, 5, 1, 0.6638830667081945);
2601  matrix_set(data_1->RAW, data_1->m+1, 5, 2, 0.6467607601353914);
2602  matrix_set(data_1->RAW, data_1->m+1, 5, 3, 0.0434948735457108);
2603  matrix_set(data_1->RAW, data_1->m+1, 6, 0, 1.0000000000000000);
2604  matrix_set(data_1->RAW, data_1->m+1, 6, 1, 0.0770493004546461);
2605  matrix_set(data_1->RAW, data_1->m+1, 6, 2, 0.3699566427075194);
2606  matrix_set(data_1->RAW, data_1->m+1, 6, 3, 0.7863539761080217);
2607  matrix_set(data_1->RAW, data_1->m+1, 7, 0, 1.0000000000000000);
2608  matrix_set(data_1->RAW, data_1->m+1, 7, 1, 0.2685233952731509);
2609  matrix_set(data_1->RAW, data_1->m+1, 7, 2, 0.8539966432782011);
2610  matrix_set(data_1->RAW, data_1->m+1, 7, 3, 0.0967159557826836);
2611  matrix_set(data_1->RAW, data_1->m+1, 8, 0, 1.0000000000000000);
2612  matrix_set(data_1->RAW, data_1->m+1, 8, 1, 0.1163951898554611);
2613  matrix_set(data_1->RAW, data_1->m+1, 8, 2, 0.7667861436369238);
2614  matrix_set(data_1->RAW, data_1->m+1, 8, 3, 0.5031912600213351);
2615  matrix_set(data_1->RAW, data_1->m+1, 9, 0, 1.0000000000000000);
2616  matrix_set(data_1->RAW, data_1->m+1, 9, 1, 0.2290251898688216);
2617  matrix_set(data_1->RAW, data_1->m+1, 9, 2, 0.4401981048538806);
2618  matrix_set(data_1->RAW, data_1->m+1, 9, 3, 0.0884616753393881);
2619 
2620  matrix_set(data_2->RAW, data_2->m+1, 0, 0, 1.0000000000000000);
2621  matrix_set(data_2->RAW, data_2->m+1, 0, 1, 0.8233234072519983);
2622  matrix_set(data_2->RAW, data_2->m+1, 0, 2, 0.3267543833513200);
2623  matrix_set(data_2->RAW, data_2->m+1, 0, 3, 0.2728942849022845);
2624  matrix_set(data_2->RAW, data_2->m+1, 1, 0, 1.0000000000000000);
2625  matrix_set(data_2->RAW, data_2->m+1, 1, 1, 0.7956168453294307);
2626  matrix_set(data_2->RAW, data_2->m+1, 1, 2, 0.3693175185473680);
2627  matrix_set(data_2->RAW, data_2->m+1, 1, 3, 0.2665038412777220);
2628  matrix_set(data_2->RAW, data_2->m+1, 2, 0, 1.0000000000000000);
2629  matrix_set(data_2->RAW, data_2->m+1, 2, 1, 0.5777227081256917);
2630  matrix_set(data_2->RAW, data_2->m+1, 2, 2, 0.2456426390463990);
2631  matrix_set(data_2->RAW, data_2->m+1, 2, 3, 0.1126634767453339);
2632  matrix_set(data_2->RAW, data_2->m+1, 3, 0, 1.0000000000000000);
2633  matrix_set(data_2->RAW, data_2->m+1, 3, 1, 0.4426030703804438);
2634  matrix_set(data_2->RAW, data_2->m+1, 3, 2, 0.1102697774064020);
2635  matrix_set(data_2->RAW, data_2->m+1, 3, 3, 0.9577384085295405);
2636  matrix_set(data_2->RAW, data_2->m+1, 4, 0, 1.0000000000000000);
2637  matrix_set(data_2->RAW, data_2->m+1, 4, 1, 0.7701104553132680);
2638  matrix_set(data_2->RAW, data_2->m+1, 4, 2, 0.8659836346403005);
2639  matrix_set(data_2->RAW, data_2->m+1, 4, 3, 0.4421972387164297);
2640 
2641  // start test code //
2642  double eps = 1e-14;
2643  double *K2 = gensvm_kernel_cross(model, data_1, data_2);
2644  mu_assert(fabs(matrix_get(K2, data_1->n, 0, 0) -
2645  0.9807518230471629) < eps,
2646  "Incorrect K2 at 0, 0");
2647  mu_assert(fabs(matrix_get(K2, data_1->n, 0, 1) -
2648  0.8852741170384059) < eps,
2649  "Incorrect K2 at 0, 1");
2650  mu_assert(fabs(matrix_get(K2, data_1->n, 0, 2) -
2651  0.7635716665765656) < eps,
2652  "Incorrect K2 at 0, 2");
2653  mu_assert(fabs(matrix_get(K2, data_1->n, 0, 3) -
2654  0.7492080432261149) < eps,
2655  "Incorrect K2 at 0, 3");
2656  mu_assert(fabs(matrix_get(K2, data_1->n, 0, 4) -
2657  0.7170903046043821) < eps,
2658  "Incorrect K2 at 0, 4");
2659  mu_assert(fabs(matrix_get(K2, data_1->n, 0, 5) -
2660  0.9391346724948219) < eps,
2661  "Incorrect K2 at 0, 5");
2662  mu_assert(fabs(matrix_get(K2, data_1->n, 0, 6) -
2663  0.7511075325872592) < eps,
2664  "Incorrect K2 at 0, 6");
2665  mu_assert(fabs(matrix_get(K2, data_1->n, 0, 7) -
2666  0.8068193111978309) < eps,
2667  "Incorrect K2 at 0, 7");
2668  mu_assert(fabs(matrix_get(K2, data_1->n, 0, 8) -
2669  0.7712432709418185) < eps,
2670  "Incorrect K2 at 0, 8");
2671  mu_assert(fabs(matrix_get(K2, data_1->n, 0, 9) -
2672  0.8700312205062914) < eps,
2673  "Incorrect K2 at 0, 9");
2674  mu_assert(fabs(matrix_get(K2, data_1->n, 1, 0) -
2675  0.9841138078975342) < eps,
2676  "Incorrect K2 at 1, 0");
2677  mu_assert(fabs(matrix_get(K2, data_1->n, 1, 1) -
2678  0.8790397003296203) < eps,
2679  "Incorrect K2 at 1, 1");
2680  mu_assert(fabs(matrix_get(K2, data_1->n, 1, 2) -
2681  0.7669459160670393) < eps,
2682  "Incorrect K2 at 1, 2");
2683  mu_assert(fabs(matrix_get(K2, data_1->n, 1, 3) -
2684  0.7703671633763146) < eps,
2685  "Incorrect K2 at 1, 3");
2686  mu_assert(fabs(matrix_get(K2, data_1->n, 1, 4) -
2687  0.7272525607549757) < eps,
2688  "Incorrect K2 at 1, 4");
2689  mu_assert(fabs(matrix_get(K2, data_1->n, 1, 5) -
2690  0.9511025236778456) < eps,
2691  "Incorrect K2 at 1, 5");
2692  mu_assert(fabs(matrix_get(K2, data_1->n, 1, 6) -
2693  0.7605364853756941) < eps,
2694  "Incorrect K2 at 1, 6");
2695  mu_assert(fabs(matrix_get(K2, data_1->n, 1, 7) -
2696  0.8282285706223327) < eps,
2697  "Incorrect K2 at 1, 7");
2698  mu_assert(fabs(matrix_get(K2, data_1->n, 1, 8) -
2699  0.7905551836844474) < eps,
2700  "Incorrect K2 at 1, 8");
2701  mu_assert(fabs(matrix_get(K2, data_1->n, 1, 9) -
2702  0.8829411638604122) < eps,
2703  "Incorrect K2 at 1, 9");
2704  mu_assert(fabs(matrix_get(K2, data_1->n, 2, 0) -
2705  0.9259609685011719) < eps,
2706  "Incorrect K2 at 2, 0");
2707  mu_assert(fabs(matrix_get(K2, data_1->n, 2, 1) -
2708  0.8145263140370310) < eps,
2709  "Incorrect K2 at 2, 1");
2710  mu_assert(fabs(matrix_get(K2, data_1->n, 2, 2) -
2711  0.8395046061962322) < eps,
2712  "Incorrect K2 at 2, 2");
2713  mu_assert(fabs(matrix_get(K2, data_1->n, 2, 3) -
2714  0.7622039915518654) < eps,
2715  "Incorrect K2 at 2, 3");
2716  mu_assert(fabs(matrix_get(K2, data_1->n, 2, 4) -
2717  0.7511426474507734) < eps,
2718  "Incorrect K2 at 2, 4");
2719  mu_assert(fabs(matrix_get(K2, data_1->n, 2, 5) -
2720  0.9415384710796756) < eps,
2721  "Incorrect K2 at 2, 5");
2722  mu_assert(fabs(matrix_get(K2, data_1->n, 2, 6) -
2723  0.7783683734706774) < eps,
2724  "Incorrect K2 at 2, 6");
2725  mu_assert(fabs(matrix_get(K2, data_1->n, 2, 7) -
2726  0.8503122106685652) < eps,
2727  "Incorrect K2 at 2, 7");
2728  mu_assert(fabs(matrix_get(K2, data_1->n, 2, 8) -
2729  0.8011956519011766) < eps,
2730  "Incorrect K2 at 2, 8");
2731  mu_assert(fabs(matrix_get(K2, data_1->n, 2, 9) -
2732  0.9458326999989332) < eps,
2733  "Incorrect K2 at 2, 9");
2734  mu_assert(fabs(matrix_get(K2, data_1->n, 3, 0) -
2735  0.8296567517703916) < eps,
2736  "Incorrect K2 at 3, 0");
2737  mu_assert(fabs(matrix_get(K2, data_1->n, 3, 1) -
2738  0.9519346106202000) < eps,
2739  "Incorrect K2 at 3, 1");
2740  mu_assert(fabs(matrix_get(K2, data_1->n, 3, 2) -
2741  0.8748910369012700) < eps,
2742  "Incorrect K2 at 3, 2");
2743  mu_assert(fabs(matrix_get(K2, data_1->n, 3, 3) -
2744  0.7304409952010390) < eps,
2745  "Incorrect K2 at 3, 3");
2746  mu_assert(fabs(matrix_get(K2, data_1->n, 3, 4) -
2747  0.9040565707355339) < eps,
2748  "Incorrect K2 at 3, 4");
2749  mu_assert(fabs(matrix_get(K2, data_1->n, 3, 5) -
2750  0.6649291594794616) < eps,
2751  "Incorrect K2 at 3, 5");
2752  mu_assert(fabs(matrix_get(K2, data_1->n, 3, 6) -
2753  0.9229382678947169) < eps,
2754  "Incorrect K2 at 3, 6");
2755  mu_assert(fabs(matrix_get(K2, data_1->n, 3, 7) -
2756  0.6306350314426549) < eps,
2757  "Incorrect K2 at 3, 7");
2758  mu_assert(fabs(matrix_get(K2, data_1->n, 3, 8) -
2759  0.7718806233578666) < eps,
2760  "Incorrect K2 at 3, 8");
2761  mu_assert(fabs(matrix_get(K2, data_1->n, 3, 9) -
2762  0.7285359056939609) < eps,
2763  "Incorrect K2 at 3, 9");
2764  mu_assert(fabs(matrix_get(K2, data_1->n, 4, 0) -
2765  0.9509298370980613) < eps,
2766  "Incorrect K2 at 4, 0");
2767  mu_assert(fabs(matrix_get(K2, data_1->n, 4, 1) -
2768  0.8040728104591074) < eps,
2769  "Incorrect K2 at 4, 1");
2770  mu_assert(fabs(matrix_get(K2, data_1->n, 4, 2) -
2771  0.6448137876591025) < eps,
2772  "Incorrect K2 at 4, 2");
2773  mu_assert(fabs(matrix_get(K2, data_1->n, 4, 3) -
2774  0.8810145544703872) < eps,
2775  "Incorrect K2 at 4, 3");
2776  mu_assert(fabs(matrix_get(K2, data_1->n, 4, 4) -
2777  0.7167145071888406) < eps,
2778  "Incorrect K2 at 4, 4");
2779  mu_assert(fabs(matrix_get(K2, data_1->n, 4, 5) -
2780  0.9268433969926227) < eps,
2781  "Incorrect K2 at 4, 5");
2782  mu_assert(fabs(matrix_get(K2, data_1->n, 4, 6) -
2783  0.7452783549758193) < eps,
2784  "Incorrect K2 at 4, 6");
2785  mu_assert(fabs(matrix_get(K2, data_1->n, 4, 7) -
2786  0.8788513369285231) < eps,
2787  "Incorrect K2 at 4, 7");
2788  mu_assert(fabs(matrix_get(K2, data_1->n, 4, 8) -
2789  0.8577568482722602) < eps,
2790  "Incorrect K2 at 4, 8");
2791  mu_assert(fabs(matrix_get(K2, data_1->n, 4, 9) -
2792  0.8117847908337736) < eps,
2793  "Incorrect K2 at 4, 9");
2794  free(K2);
2795 
2796  // end test code //
2797 
2798  gensvm_free_model(model);
2799  gensvm_free_data(data_1);
2800  gensvm_free_data(data_2);
2801 
2802  return NULL;
2803 }
2804 
2805 char *test_kernel_cross_poly()
2806 {
2807  struct GenModel *model = gensvm_init_model();
2808  struct GenData *data_1 = gensvm_init_data();
2809  struct GenData *data_2 = gensvm_init_data();
2810 
2811  // setup //
2812  data_1->n = 10;
2813  data_1->m = 3;
2814  data_1->RAW = Calloc(double, data_1->n * (data_1->m + 1));
2815 
2816  data_2->n = 5;
2817  data_2->m = 3;
2818  data_2->RAW = Calloc(double, data_2->n * (data_2->m + 1));
2819 
2820  model->n = 10;
2821  model->m = 3;
2822  model->kerneltype = K_POLY;
2823  model->gamma = 1.5;
2824  model->coef = 3.0;
2825  model->degree = 1.78;
2826 
2827  matrix_set(data_1->RAW, data_1->m+1, 0, 0, 1.0000000000000000);
2828  matrix_set(data_1->RAW, data_1->m+1, 0, 1, 0.8056271362589000);
2829  matrix_set(data_1->RAW, data_1->m+1, 0, 2, 0.4874175854113872);
2830  matrix_set(data_1->RAW, data_1->m+1, 0, 3, 0.4453015882771756);
2831  matrix_set(data_1->RAW, data_1->m+1, 1, 0, 1.0000000000000000);
2832  matrix_set(data_1->RAW, data_1->m+1, 1, 1, 0.7940590105180981);
2833  matrix_set(data_1->RAW, data_1->m+1, 1, 2, 0.1861049005485224);
2834  matrix_set(data_1->RAW, data_1->m+1, 1, 3, 0.8469394287449229);
2835  matrix_set(data_1->RAW, data_1->m+1, 2, 0, 1.0000000000000000);
2836  matrix_set(data_1->RAW, data_1->m+1, 2, 1, 0.0294257611061681);
2837  matrix_set(data_1->RAW, data_1->m+1, 2, 2, 0.0242717976065267);
2838  matrix_set(data_1->RAW, data_1->m+1, 2, 3, 0.5039128672814752);
2839  matrix_set(data_1->RAW, data_1->m+1, 3, 0, 1.0000000000000000);
2840  matrix_set(data_1->RAW, data_1->m+1, 3, 1, 0.1746563833537603);
2841  matrix_set(data_1->RAW, data_1->m+1, 3, 2, 0.9135736087631979);
2842  matrix_set(data_1->RAW, data_1->m+1, 3, 3, 0.5270258081021366);
2843  matrix_set(data_1->RAW, data_1->m+1, 4, 0, 1.0000000000000000);
2844  matrix_set(data_1->RAW, data_1->m+1, 4, 1, 0.0022298761599785);
2845  matrix_set(data_1->RAW, data_1->m+1, 4, 2, 0.3773482059713607);
2846  matrix_set(data_1->RAW, data_1->m+1, 4, 3, 0.8009654729622842);
2847  matrix_set(data_1->RAW, data_1->m+1, 5, 0, 1.0000000000000000);
2848  matrix_set(data_1->RAW, data_1->m+1, 5, 1, 0.6638830667081945);
2849  matrix_set(data_1->RAW, data_1->m+1, 5, 2, 0.6467607601353914);
2850  matrix_set(data_1->RAW, data_1->m+1, 5, 3, 0.0434948735457108);
2851  matrix_set(data_1->RAW, data_1->m+1, 6, 0, 1.0000000000000000);
2852  matrix_set(data_1->RAW, data_1->m+1, 6, 1, 0.0770493004546461);
2853  matrix_set(data_1->RAW, data_1->m+1, 6, 2, 0.3699566427075194);
2854  matrix_set(data_1->RAW, data_1->m+1, 6, 3, 0.7863539761080217);
2855  matrix_set(data_1->RAW, data_1->m+1, 7, 0, 1.0000000000000000);
2856  matrix_set(data_1->RAW, data_1->m+1, 7, 1, 0.2685233952731509);
2857  matrix_set(data_1->RAW, data_1->m+1, 7, 2, 0.8539966432782011);
2858  matrix_set(data_1->RAW, data_1->m+1, 7, 3, 0.0967159557826836);
2859  matrix_set(data_1->RAW, data_1->m+1, 8, 0, 1.0000000000000000);
2860  matrix_set(data_1->RAW, data_1->m+1, 8, 1, 0.1163951898554611);
2861  matrix_set(data_1->RAW, data_1->m+1, 8, 2, 0.7667861436369238);
2862  matrix_set(data_1->RAW, data_1->m+1, 8, 3, 0.5031912600213351);
2863  matrix_set(data_1->RAW, data_1->m+1, 9, 0, 1.0000000000000000);
2864  matrix_set(data_1->RAW, data_1->m+1, 9, 1, 0.2290251898688216);
2865  matrix_set(data_1->RAW, data_1->m+1, 9, 2, 0.4401981048538806);
2866  matrix_set(data_1->RAW, data_1->m+1, 9, 3, 0.0884616753393881);
2867 
2868  matrix_set(data_2->RAW, data_2->m+1, 0, 0, 1.0000000000000000);
2869  matrix_set(data_2->RAW, data_2->m+1, 0, 1, 0.8233234072519983);
2870  matrix_set(data_2->RAW, data_2->m+1, 0, 2, 0.3267543833513200);
2871  matrix_set(data_2->RAW, data_2->m+1, 0, 3, 0.2728942849022845);
2872  matrix_set(data_2->RAW, data_2->m+1, 1, 0, 1.0000000000000000);
2873  matrix_set(data_2->RAW, data_2->m+1, 1, 1, 0.7956168453294307);
2874  matrix_set(data_2->RAW, data_2->m+1, 1, 2, 0.3693175185473680);
2875  matrix_set(data_2->RAW, data_2->m+1, 1, 3, 0.2665038412777220);
2876  matrix_set(data_2->RAW, data_2->m+1, 2, 0, 1.0000000000000000);
2877  matrix_set(data_2->RAW, data_2->m+1, 2, 1, 0.5777227081256917);
2878  matrix_set(data_2->RAW, data_2->m+1, 2, 2, 0.2456426390463990);
2879  matrix_set(data_2->RAW, data_2->m+1, 2, 3, 0.1126634767453339);
2880  matrix_set(data_2->RAW, data_2->m+1, 3, 0, 1.0000000000000000);
2881  matrix_set(data_2->RAW, data_2->m+1, 3, 1, 0.4426030703804438);
2882  matrix_set(data_2->RAW, data_2->m+1, 3, 2, 0.1102697774064020);
2883  matrix_set(data_2->RAW, data_2->m+1, 3, 3, 0.9577384085295405);
2884  matrix_set(data_2->RAW, data_2->m+1, 4, 0, 1.0000000000000000);
2885  matrix_set(data_2->RAW, data_2->m+1, 4, 1, 0.7701104553132680);
2886  matrix_set(data_2->RAW, data_2->m+1, 4, 2, 0.8659836346403005);
2887  matrix_set(data_2->RAW, data_2->m+1, 4, 3, 0.4421972387164297);
2888 
2889  // start test code //
2890  double eps = 1e-14;
2891  double *K2 = gensvm_kernel_cross(model, data_1, data_2);
2892  mu_assert(fabs(matrix_get(K2, data_1->n, 0, 0) -
2893  14.0660499715713421) < eps,
2894  "Incorrect K2 at 0, 0");
2895  mu_assert(fabs(matrix_get(K2, data_1->n, 0, 1) -
2896  14.0798736090876808) < eps,
2897  "Incorrect K2 at 0, 1");
2898  mu_assert(fabs(matrix_get(K2, data_1->n, 0, 2) -
2899  8.1700400917705256) < eps,
2900  "Incorrect K2 at 0, 2");
2901  mu_assert(fabs(matrix_get(K2, data_1->n, 0, 3) -
2902  11.1676455855990469) < eps,
2903  "Incorrect K2 at 0, 3");
2904  mu_assert(fabs(matrix_get(K2, data_1->n, 0, 4) -
2905  9.3728783610105122) < eps,
2906  "Incorrect K2 at 0, 4");
2907  mu_assert(fabs(matrix_get(K2, data_1->n, 0, 5) -
2908  12.6182273329088108) < eps,
2909  "Incorrect K2 at 0, 5");
2910  mu_assert(fabs(matrix_get(K2, data_1->n, 0, 6) -
2911  9.7694076615604182) < eps,
2912  "Incorrect K2 at 0, 6");
2913  mu_assert(fabs(matrix_get(K2, data_1->n, 0, 7) -
2914  10.7135530249071351) < eps,
2915  "Incorrect K2 at 0, 7");
2916  mu_assert(fabs(matrix_get(K2, data_1->n, 0, 8) -
2917  10.3924703115971937) < eps,
2918  "Incorrect K2 at 0, 8");
2919  mu_assert(fabs(matrix_get(K2, data_1->n, 0, 9) -
2920  9.4643617813593419) < eps,
2921  "Incorrect K2 at 0, 9");
2922  mu_assert(fabs(matrix_get(K2, data_1->n, 1, 0) -
2923  14.0284757046542925) < eps,
2924  "Incorrect K2 at 1, 0");
2925  mu_assert(fabs(matrix_get(K2, data_1->n, 1, 1) -
2926  13.9144650311002316) < eps,
2927  "Incorrect K2 at 1, 1");
2928  mu_assert(fabs(matrix_get(K2, data_1->n, 1, 2) -
2929  8.1499265608165583) < eps,
2930  "Incorrect K2 at 1, 2");
2931  mu_assert(fabs(matrix_get(K2, data_1->n, 1, 3) -
2932  11.4045391037528390) < eps,
2933  "Incorrect K2 at 1, 3");
2934  mu_assert(fabs(matrix_get(K2, data_1->n, 1, 4) -
2935  9.4504735861367735) < eps,
2936  "Incorrect K2 at 1, 4");
2937  mu_assert(fabs(matrix_get(K2, data_1->n, 1, 5) -
2938  12.6901332253769485) < eps,
2939  "Incorrect K2 at 1, 5");
2940  mu_assert(fabs(matrix_get(K2, data_1->n, 1, 6) -
2941  9.8317381138302018) < eps,
2942  "Incorrect K2 at 1, 6");
2943  mu_assert(fabs(matrix_get(K2, data_1->n, 1, 7) -
2944  10.9280234697682062) < eps,
2945  "Incorrect K2 at 1, 7");
2946  mu_assert(fabs(matrix_get(K2, data_1->n, 1, 8) -
2947  10.5883823060327860) < eps,
2948  "Incorrect K2 at 1, 8");
2949  mu_assert(fabs(matrix_get(K2, data_1->n, 1, 9) -
2950  9.5490652847135138) < eps,
2951  "Incorrect K2 at 1, 9");
2952  mu_assert(fabs(matrix_get(K2, data_1->n, 2, 0) -
2953  11.5485754684510606) < eps,
2954  "Incorrect K2 at 2, 0");
2955  mu_assert(fabs(matrix_get(K2, data_1->n, 2, 1) -
2956  11.2735171075936282) < eps,
2957  "Incorrect K2 at 2, 1");
2958  mu_assert(fabs(matrix_get(K2, data_1->n, 2, 2) -
2959  7.5769874635472778) < eps,
2960  "Incorrect K2 at 2, 2");
2961  mu_assert(fabs(matrix_get(K2, data_1->n, 2, 3) -
2962  9.6665605291258849) < eps,
2963  "Incorrect K2 at 2, 3");
2964  mu_assert(fabs(matrix_get(K2, data_1->n, 2, 4) -
2965  8.2678047879187648) < eps,
2966  "Incorrect K2 at 2, 4");
2967  mu_assert(fabs(matrix_get(K2, data_1->n, 2, 5) -
2968  10.8709836661754018) < eps,
2969  "Incorrect K2 at 2, 5");
2970  mu_assert(fabs(matrix_get(K2, data_1->n, 2, 6) -
2971  8.5376169230827301) < eps,
2972  "Incorrect K2 at 2, 6");
2973  mu_assert(fabs(matrix_get(K2, data_1->n, 2, 7) -
2974  9.6025396489681700) < eps,
2975  "Incorrect K2 at 2, 7");
2976  mu_assert(fabs(matrix_get(K2, data_1->n, 2, 8) -
2977  9.1503562342971971) < eps,
2978  "Incorrect K2 at 2, 8");
2979  mu_assert(fabs(matrix_get(K2, data_1->n, 2, 9) -
2980  8.7190361363030764) < eps,
2981  "Incorrect K2 at 2, 9");
2982  mu_assert(fabs(matrix_get(K2, data_1->n, 3, 0) -
2983  13.1667427919927871) < eps,
2984  "Incorrect K2 at 3, 0");
2985  mu_assert(fabs(matrix_get(K2, data_1->n, 3, 1) -
2986  16.1629665429693823) < eps,
2987  "Incorrect K2 at 3, 1");
2988  mu_assert(fabs(matrix_get(K2, data_1->n, 3, 2) -
2989  10.5015908640040099) < eps,
2990  "Incorrect K2 at 3, 2");
2991  mu_assert(fabs(matrix_get(K2, data_1->n, 3, 3) -
2992  11.9214318530013443) < eps,
2993  "Incorrect K2 at 3, 3");
2994  mu_assert(fabs(matrix_get(K2, data_1->n, 3, 4) -
2995  12.9437638270688211) < eps,
2996  "Incorrect K2 at 3, 4");
2997  mu_assert(fabs(matrix_get(K2, data_1->n, 3, 5) -
2998  9.8267375915304900) < eps,
2999  "Incorrect K2 at 3, 5");
3000  mu_assert(fabs(matrix_get(K2, data_1->n, 3, 6) -
3001  13.0942580006333298) < eps,
3002  "Incorrect K2 at 3, 6");
3003  mu_assert(fabs(matrix_get(K2, data_1->n, 3, 7) -
3004  9.1036164336081900) < eps,
3005  "Incorrect K2 at 3, 7");
3006  mu_assert(fabs(matrix_get(K2, data_1->n, 3, 8) -
3007  11.4137186988419348) < eps,
3008  "Incorrect K2 at 3, 8");
3009  mu_assert(fabs(matrix_get(K2, data_1->n, 3, 9) -
3010  8.6105081033670565) < eps,
3011  "Incorrect K2 at 3, 9");
3012  mu_assert(fabs(matrix_get(K2, data_1->n, 4, 0) -
3013  16.6753988505663493) < eps,
3014  "Incorrect K2 at 4, 0");
3015  mu_assert(fabs(matrix_get(K2, data_1->n, 4, 1) -
3016  15.8396512236024520) < eps,
3017  "Incorrect K2 at 4, 1");
3018  mu_assert(fabs(matrix_get(K2, data_1->n, 4, 2) -
3019  8.8303654890651160) < eps,
3020  "Incorrect K2 at 4, 2");
3021  mu_assert(fabs(matrix_get(K2, data_1->n, 4, 3) -
3022  15.9428461498604186) < eps,
3023  "Incorrect K2 at 4, 3");
3024  mu_assert(fabs(matrix_get(K2, data_1->n, 4, 4) -
3025  11.9205101781336413) < eps,
3026  "Incorrect K2 at 4, 4");
3027  mu_assert(fabs(matrix_get(K2, data_1->n, 4, 5) -
3028  15.3360611842713368) < eps,
3029  "Incorrect K2 at 4, 5");
3030  mu_assert(fabs(matrix_get(K2, data_1->n, 4, 6) -
3031  12.2768145090113094) < eps,
3032  "Incorrect K2 at 4, 6");
3033  mu_assert(fabs(matrix_get(K2, data_1->n, 4, 7) -
3034  14.4512803240791001) < eps,
3035  "Incorrect K2 at 4, 7");
3036  mu_assert(fabs(matrix_get(K2, data_1->n, 4, 8) -
3037  14.3401441810752441) < eps,
3038  "Incorrect K2 at 4, 8");
3039  mu_assert(fabs(matrix_get(K2, data_1->n, 4, 9) -
3040  11.2489550339576638) < eps,
3041  "Incorrect K2 at 4, 9");
3042  free(K2);
3043 
3044  // end test code //
3045 
3046  gensvm_free_model(model);
3047  gensvm_free_data(data_1);
3048  gensvm_free_data(data_2);
3049 
3050  return NULL;
3051 }
3052 
3053 char *test_kernel_cross_sigmoid()
3054 {
3055  struct GenModel *model = gensvm_init_model();
3056  struct GenData *data_1 = gensvm_init_data();
3057  struct GenData *data_2 = gensvm_init_data();
3058 
3059  // setup //
3060  data_1->n = 10;
3061  data_1->m = 3;
3062  data_1->RAW = Calloc(double, data_1->n * (data_1->m + 1));
3063 
3064  data_2->n = 5;
3065  data_2->m = 3;
3066  data_2->RAW = Calloc(double, data_2->n * (data_2->m + 1));
3067 
3068  model->n = 10;
3069  model->m = 3;
3070  model->kerneltype = K_SIGMOID;
3071  model->gamma = 1.23;
3072  model->coef = 1.6;
3073 
3074  matrix_set(data_1->RAW, data_1->m+1, 0, 0, 1.0000000000000000);
3075  matrix_set(data_1->RAW, data_1->m+1, 0, 1, 0.8056271362589000);
3076  matrix_set(data_1->RAW, data_1->m+1, 0, 2, 0.4874175854113872);
3077  matrix_set(data_1->RAW, data_1->m+1, 0, 3, 0.4453015882771756);
3078  matrix_set(data_1->RAW, data_1->m+1, 1, 0, 1.0000000000000000);
3079  matrix_set(data_1->RAW, data_1->m+1, 1, 1, 0.7940590105180981);
3080  matrix_set(data_1->RAW, data_1->m+1, 1, 2, 0.1861049005485224);
3081  matrix_set(data_1->RAW, data_1->m+1, 1, 3, 0.8469394287449229);
3082  matrix_set(data_1->RAW, data_1->m+1, 2, 0, 1.0000000000000000);
3083  matrix_set(data_1->RAW, data_1->m+1, 2, 1, 0.0294257611061681);
3084  matrix_set(data_1->RAW, data_1->m+1, 2, 2, 0.0242717976065267);
3085  matrix_set(data_1->RAW, data_1->m+1, 2, 3, 0.5039128672814752);
3086  matrix_set(data_1->RAW, data_1->m+1, 3, 0, 1.0000000000000000);
3087  matrix_set(data_1->RAW, data_1->m+1, 3, 1, 0.1746563833537603);
3088  matrix_set(data_1->RAW, data_1->m+1, 3, 2, 0.9135736087631979);
3089  matrix_set(data_1->RAW, data_1->m+1, 3, 3, 0.5270258081021366);
3090  matrix_set(data_1->RAW, data_1->m+1, 4, 0, 1.0000000000000000);
3091  matrix_set(data_1->RAW, data_1->m+1, 4, 1, 0.0022298761599785);
3092  matrix_set(data_1->RAW, data_1->m+1, 4, 2, 0.3773482059713607);
3093  matrix_set(data_1->RAW, data_1->m+1, 4, 3, 0.8009654729622842);
3094  matrix_set(data_1->RAW, data_1->m+1, 5, 0, 1.0000000000000000);
3095  matrix_set(data_1->RAW, data_1->m+1, 5, 1, 0.6638830667081945);
3096  matrix_set(data_1->RAW, data_1->m+1, 5, 2, 0.6467607601353914);
3097  matrix_set(data_1->RAW, data_1->m+1, 5, 3, 0.0434948735457108);
3098  matrix_set(data_1->RAW, data_1->m+1, 6, 0, 1.0000000000000000);
3099  matrix_set(data_1->RAW, data_1->m+1, 6, 1, 0.0770493004546461);
3100  matrix_set(data_1->RAW, data_1->m+1, 6, 2, 0.3699566427075194);
3101  matrix_set(data_1->RAW, data_1->m+1, 6, 3, 0.7863539761080217);
3102  matrix_set(data_1->RAW, data_1->m+1, 7, 0, 1.0000000000000000);
3103  matrix_set(data_1->RAW, data_1->m+1, 7, 1, 0.2685233952731509);
3104  matrix_set(data_1->RAW, data_1->m+1, 7, 2, 0.8539966432782011);
3105  matrix_set(data_1->RAW, data_1->m+1, 7, 3, 0.0967159557826836);
3106  matrix_set(data_1->RAW, data_1->m+1, 8, 0, 1.0000000000000000);
3107  matrix_set(data_1->RAW, data_1->m+1, 8, 1, 0.1163951898554611);
3108  matrix_set(data_1->RAW, data_1->m+1, 8, 2, 0.7667861436369238);
3109  matrix_set(data_1->RAW, data_1->m+1, 8, 3, 0.5031912600213351);
3110  matrix_set(data_1->RAW, data_1->m+1, 9, 0, 1.0000000000000000);
3111  matrix_set(data_1->RAW, data_1->m+1, 9, 1, 0.2290251898688216);
3112  matrix_set(data_1->RAW, data_1->m+1, 9, 2, 0.4401981048538806);
3113  matrix_set(data_1->RAW, data_1->m+1, 9, 3, 0.0884616753393881);
3114 
3115  matrix_set(data_2->RAW, data_2->m+1, 0, 0, 1.0000000000000000);
3116  matrix_set(data_2->RAW, data_2->m+1, 0, 1, 0.8233234072519983);
3117  matrix_set(data_2->RAW, data_2->m+1, 0, 2, 0.3267543833513200);
3118  matrix_set(data_2->RAW, data_2->m+1, 0, 3, 0.2728942849022845);
3119  matrix_set(data_2->RAW, data_2->m+1, 1, 0, 1.0000000000000000);
3120  matrix_set(data_2->RAW, data_2->m+1, 1, 1, 0.7956168453294307);
3121  matrix_set(data_2->RAW, data_2->m+1, 1, 2, 0.3693175185473680);
3122  matrix_set(data_2->RAW, data_2->m+1, 1, 3, 0.2665038412777220);
3123  matrix_set(data_2->RAW, data_2->m+1, 2, 0, 1.0000000000000000);
3124  matrix_set(data_2->RAW, data_2->m+1, 2, 1, 0.5777227081256917);
3125  matrix_set(data_2->RAW, data_2->m+1, 2, 2, 0.2456426390463990);
3126  matrix_set(data_2->RAW, data_2->m+1, 2, 3, 0.1126634767453339);
3127  matrix_set(data_2->RAW, data_2->m+1, 3, 0, 1.0000000000000000);
3128  matrix_set(data_2->RAW, data_2->m+1, 3, 1, 0.4426030703804438);
3129  matrix_set(data_2->RAW, data_2->m+1, 3, 2, 0.1102697774064020);
3130  matrix_set(data_2->RAW, data_2->m+1, 3, 3, 0.9577384085295405);
3131  matrix_set(data_2->RAW, data_2->m+1, 4, 0, 1.0000000000000000);
3132  matrix_set(data_2->RAW, data_2->m+1, 4, 1, 0.7701104553132680);
3133  matrix_set(data_2->RAW, data_2->m+1, 4, 2, 0.8659836346403005);
3134  matrix_set(data_2->RAW, data_2->m+1, 4, 3, 0.4421972387164297);
3135 
3136  // start test code //
3137  double eps = 1e-14;
3138  double *K2 = gensvm_kernel_cross(model, data_1, data_2);
3139 
3140  mu_assert(fabs(matrix_get(K2, data_1->n, 0, 0) -
3141  0.9920395702373311) < eps,
3142  "Incorrect K2 at 0, 0");
3143  mu_assert(fabs(matrix_get(K2, data_1->n, 0, 1) -
3144  0.9920712050042086) < eps,
3145  "Incorrect K2 at 0, 1");
3146  mu_assert(fabs(matrix_get(K2, data_1->n, 0, 2) -
3147  0.9476993343669046) < eps,
3148  "Incorrect K2 at 0, 2");
3149  mu_assert(fabs(matrix_get(K2, data_1->n, 0, 3) -
3150  0.9809051895947648) < eps,
3151  "Incorrect K2 at 0, 3");
3152  mu_assert(fabs(matrix_get(K2, data_1->n, 0, 4) -
3153  0.9656014407964381) < eps,
3154  "Incorrect K2 at 0, 4");
3155  mu_assert(fabs(matrix_get(K2, data_1->n, 0, 5) -
3156  0.9878041245323028) < eps,
3157  "Incorrect K2 at 0, 5");
3158  mu_assert(fabs(matrix_get(K2, data_1->n, 0, 6) -
3159  0.9699033492645315) < eps,
3160  "Incorrect K2 at 0, 6");
3161  mu_assert(fabs(matrix_get(K2, data_1->n, 0, 7) -
3162  0.9779225156794014) < eps,
3163  "Incorrect K2 at 0, 7");
3164  mu_assert(fabs(matrix_get(K2, data_1->n, 0, 8) -
3165  0.9754999374304111) < eps,
3166  "Incorrect K2 at 0, 8");
3167  mu_assert(fabs(matrix_get(K2, data_1->n, 0, 9) -
3168  0.9666518758877651) < eps,
3169  "Incorrect K2 at 0, 9");
3170  mu_assert(fabs(matrix_get(K2, data_1->n, 1, 0) -
3171  0.9919528767612884) < eps,
3172  "Incorrect K2 at 1, 0");
3173  mu_assert(fabs(matrix_get(K2, data_1->n, 1, 1) -
3174  0.9916833786531655) < eps,
3175  "Incorrect K2 at 1, 1");
3176  mu_assert(fabs(matrix_get(K2, data_1->n, 1, 2) -
3177  0.9473218250023265) < eps,
3178  "Incorrect K2 at 1, 2");
3179  mu_assert(fabs(matrix_get(K2, data_1->n, 1, 3) -
3180  0.9822808818850081) < eps,
3181  "Incorrect K2 at 1, 3");
3182  mu_assert(fabs(matrix_get(K2, data_1->n, 1, 4) -
3183  0.9664947467723793) < eps,
3184  "Incorrect K2 at 1, 4");
3185  mu_assert(fabs(matrix_get(K2, data_1->n, 1, 5) -
3186  0.9880653879683305) < eps,
3187  "Incorrect K2 at 1, 5");
3188  mu_assert(fabs(matrix_get(K2, data_1->n, 1, 6) -
3189  0.9705231426655428) < eps,
3190  "Incorrect K2 at 1, 6");
3191  mu_assert(fabs(matrix_get(K2, data_1->n, 1, 7) -
3192  0.9793914678629526) < eps,
3193  "Incorrect K2 at 1, 7");
3194  mu_assert(fabs(matrix_get(K2, data_1->n, 1, 8) -
3195  0.9770114192540243) < eps,
3196  "Incorrect K2 at 1, 8");
3197  mu_assert(fabs(matrix_get(K2, data_1->n, 1, 9) -
3198  0.9675925213675517) < eps,
3199  "Incorrect K2 at 1, 9");
3200  mu_assert(fabs(matrix_get(K2, data_1->n, 2, 0) -
3201  0.9830631959900493) < eps,
3202  "Incorrect K2 at 2, 0");
3203  mu_assert(fabs(matrix_get(K2, data_1->n, 2, 1) -
3204  0.9815341888355711) < eps,
3205  "Incorrect K2 at 2, 1");
3206  mu_assert(fabs(matrix_get(K2, data_1->n, 2, 2) -
3207  0.9351678264557334) < eps,
3208  "Incorrect K2 at 2, 2");
3209  mu_assert(fabs(matrix_get(K2, data_1->n, 2, 3) -
3210  0.9688485293248640) < eps,
3211  "Incorrect K2 at 2, 3");
3212  mu_assert(fabs(matrix_get(K2, data_1->n, 2, 4) -
3213  0.9494915246914850) < eps,
3214  "Incorrect K2 at 2, 4");
3215  mu_assert(fabs(matrix_get(K2, data_1->n, 2, 5) -
3216  0.9790117279097025) < eps,
3217  "Incorrect K2 at 2, 5");
3218  mu_assert(fabs(matrix_get(K2, data_1->n, 2, 6) -
3219  0.9540901254104273) < eps,
3220  "Incorrect K2 at 2, 6");
3221  mu_assert(fabs(matrix_get(K2, data_1->n, 2, 7) -
3222  0.9681710508625928) < eps,
3223  "Incorrect K2 at 2, 7");
3224  mu_assert(fabs(matrix_get(K2, data_1->n, 2, 8) -
3225  0.9628881304379768) < eps,
3226  "Incorrect K2 at 2, 8");
3227  mu_assert(fabs(matrix_get(K2, data_1->n, 2, 9) -
3228  0.9569175771195083) < eps,
3229  "Incorrect K2 at 2, 9");
3230  mu_assert(fabs(matrix_get(K2, data_1->n, 3, 0) -
3231  0.9896480192770086) < eps,
3232  "Incorrect K2 at 3, 0");
3233  mu_assert(fabs(matrix_get(K2, data_1->n, 3, 1) -
3234  0.9955708509948572) < eps,
3235  "Incorrect K2 at 3, 1");
3236  mu_assert(fabs(matrix_get(K2, data_1->n, 3, 2) -
3237  0.9763550511314351) < eps,
3238  "Incorrect K2 at 3, 2");
3239  mu_assert(fabs(matrix_get(K2, data_1->n, 3, 3) -
3240  0.9849157087004718) < eps,
3241  "Incorrect K2 at 3, 3");
3242  mu_assert(fabs(matrix_get(K2, data_1->n, 3, 4) -
3243  0.9889385756779369) < eps,
3244  "Incorrect K2 at 3, 4");
3245  mu_assert(fabs(matrix_get(K2, data_1->n, 3, 5) -
3246  0.9704739495606978) < eps,
3247  "Incorrect K2 at 3, 5");
3248  mu_assert(fabs(matrix_get(K2, data_1->n, 3, 6) -
3249  0.9894230831842615) < eps,
3250  "Incorrect K2 at 3, 6");
3251  mu_assert(fabs(matrix_get(K2, data_1->n, 3, 7) -
3252  0.9622882117865678) < eps,
3253  "Incorrect K2 at 3, 7");
3254  mu_assert(fabs(matrix_get(K2, data_1->n, 3, 8) -
3255  0.9823319222305995) < eps,
3256  "Incorrect K2 at 3, 8");
3257  mu_assert(fabs(matrix_get(K2, data_1->n, 3, 9) -
3258  0.9552504472873038) < eps,
3259  "Incorrect K2 at 3, 9");
3260  mu_assert(fabs(matrix_get(K2, data_1->n, 4, 0) -
3261  0.9961426616053822) < eps,
3262  "Incorrect K2 at 4, 0");
3263  mu_assert(fabs(matrix_get(K2, data_1->n, 4, 1) -
3264  0.9951625370745047) < eps,
3265  "Incorrect K2 at 4, 1");
3266  mu_assert(fabs(matrix_get(K2, data_1->n, 4, 2) -
3267  0.9585556905472743) < eps,
3268  "Incorrect K2 at 4, 2");
3269  mu_assert(fabs(matrix_get(K2, data_1->n, 4, 3) -
3270  0.9952971844072107) < eps,
3271  "Incorrect K2 at 4, 3");
3272  mu_assert(fabs(matrix_get(K2, data_1->n, 4, 4) -
3273  0.9849114167202919) < eps,
3274  "Incorrect K2 at 4, 4");
3275  mu_assert(fabs(matrix_get(K2, data_1->n, 4, 5) -
3276  0.9944417095668610) < eps,
3277  "Incorrect K2 at 4, 5");
3278  mu_assert(fabs(matrix_get(K2, data_1->n, 4, 6) -
3279  0.9864738775087318) < eps,
3280  "Incorrect K2 at 4, 6");
3281  mu_assert(fabs(matrix_get(K2, data_1->n, 4, 7) -
3282  0.9928713082004123) < eps,
3283  "Incorrect K2 at 4, 7");
3284  mu_assert(fabs(matrix_get(K2, data_1->n, 4, 8) -
3285  0.9926416525703272) < eps,
3286  "Incorrect K2 at 4, 8");
3287  mu_assert(fabs(matrix_get(K2, data_1->n, 4, 9) -
3288  0.9813903448088843) < eps,
3289  "Incorrect K2 at 4, 9");
3290 
3291  free(K2);
3292 
3293  // end test code //
3294 
3295  gensvm_free_model(model);
3296  gensvm_free_data(data_1);
3297  gensvm_free_data(data_2);
3298 
3299  return NULL;
3300 }
3301 
3302 char *test_kernel_trainfactor()
3303 {
3304  struct GenData *data = gensvm_init_data();
3305 
3306  data->n = 10;
3307  data->m = 5;
3308  data->K = 3;
3309  int r = 7;
3310 
3311  double *P = Calloc(double, data->n * r);
3312  double *Sigma = Calloc(double, r);
3313 
3314  matrix_set(P, r, 0, 0, 0.8056271362589000);
3315  matrix_set(P, r, 0, 1, 0.4874175854113872);
3316  matrix_set(P, r, 0, 2, 0.4453015882771756);
3317  matrix_set(P, r, 0, 3, 0.8233234072519983);
3318  matrix_set(P, r, 0, 4, 0.2728942849022845);
3319  matrix_set(P, r, 0, 5, 0.4221779040953508);
3320  matrix_set(P, r, 0, 6, 0.5090230605656835);
3321  matrix_set(P, r, 1, 0, 0.7940590105180981);
3322  matrix_set(P, r, 1, 1, 0.1861049005485224);
3323  matrix_set(P, r, 1, 2, 0.8469394287449229);
3324  matrix_set(P, r, 1, 3, 0.7956168453294307);
3325  matrix_set(P, r, 1, 4, 0.2665038412777220);
3326  matrix_set(P, r, 1, 5, 0.1657896146622650);
3327  matrix_set(P, r, 1, 6, 0.9000985899630121);
3328  matrix_set(P, r, 2, 0, 0.0294257611061681);
3329  matrix_set(P, r, 2, 1, 0.0242717976065267);
3330  matrix_set(P, r, 2, 2, 0.5039128672814752);
3331  matrix_set(P, r, 2, 3, 0.5777227081256917);
3332  matrix_set(P, r, 2, 4, 0.1126634767453339);
3333  matrix_set(P, r, 2, 5, 0.2472125660924395);
3334  matrix_set(P, r, 2, 6, 0.1140159498084029);
3335  matrix_set(P, r, 3, 0, 0.1746563833537603);
3336  matrix_set(P, r, 3, 1, 0.9135736087631979);
3337  matrix_set(P, r, 3, 2, 0.5270258081021366);
3338  matrix_set(P, r, 3, 3, 0.4426030703804438);
3339  matrix_set(P, r, 3, 4, 0.9577384085295405);
3340  matrix_set(P, r, 3, 5, 0.7987328321610475);
3341  matrix_set(P, r, 3, 6, 0.3920414766506218);
3342  matrix_set(P, r, 4, 0, 0.0022298761599785);
3343  matrix_set(P, r, 4, 1, 0.3773482059713607);
3344  matrix_set(P, r, 4, 2, 0.8009654729622842);
3345  matrix_set(P, r, 4, 3, 0.7701104553132680);
3346  matrix_set(P, r, 4, 4, 0.4421972387164297);
3347  matrix_set(P, r, 4, 5, 0.9763647809741268);
3348  matrix_set(P, r, 4, 6, 0.7735127328107272);
3349  matrix_set(P, r, 5, 0, 0.6638830667081945);
3350  matrix_set(P, r, 5, 1, 0.6467607601353914);
3351  matrix_set(P, r, 5, 2, 0.0434948735457108);
3352  matrix_set(P, r, 5, 3, 0.3267543833513200);
3353  matrix_set(P, r, 5, 4, 0.3993579061297995);
3354  matrix_set(P, r, 5, 5, 0.5095430570208566);
3355  matrix_set(P, r, 5, 6, 0.0437246682449493);
3356  matrix_set(P, r, 6, 0, 0.0770493004546461);
3357  matrix_set(P, r, 6, 1, 0.3699566427075194);
3358  matrix_set(P, r, 6, 2, 0.7863539761080217);
3359  matrix_set(P, r, 6, 3, 0.3693175185473680);
3360  matrix_set(P, r, 6, 4, 0.9137371110726166);
3361  matrix_set(P, r, 6, 5, 0.1190008864254177);
3362  matrix_set(P, r, 6, 6, 0.3534695686769205);
3363  matrix_set(P, r, 7, 0, 0.2685233952731509);
3364  matrix_set(P, r, 7, 1, 0.8539966432782011);
3365  matrix_set(P, r, 7, 2, 0.0967159557826836);
3366  matrix_set(P, r, 7, 3, 0.2456426390463990);
3367  matrix_set(P, r, 7, 4, 0.0191704319054138);
3368  matrix_set(P, r, 7, 5, 0.5211738041619068);
3369  matrix_set(P, r, 7, 6, 0.0966039750517987);
3370  matrix_set(P, r, 8, 0, 0.1163951898554611);
3371  matrix_set(P, r, 8, 1, 0.7667861436369238);
3372  matrix_set(P, r, 8, 2, 0.5031912600213351);
3373  matrix_set(P, r, 8, 3, 0.1102697774064020);
3374  matrix_set(P, r, 8, 4, 0.4826593547737735);
3375  matrix_set(P, r, 8, 5, 0.2491297759535341);
3376  matrix_set(P, r, 8, 6, 0.7277927065471604);
3377  matrix_set(P, r, 9, 0, 0.2290251898688216);
3378  matrix_set(P, r, 9, 1, 0.4401981048538806);
3379  matrix_set(P, r, 9, 2, 0.0884616753393881);
3380  matrix_set(P, r, 9, 3, 0.8659836346403005);
3381  matrix_set(P, r, 9, 4, 0.1028774221216107);
3382  matrix_set(P, r, 9, 5, 0.6189568847484389);
3383  matrix_set(P, r, 9, 6, 0.6893982492936992);
3384 
3385  Sigma[0] = 0.8917076715220298;
3386  Sigma[1] = 0.7448958325189663;
3387  Sigma[2] = 0.7292497207505059;
3388  Sigma[3] = 0.0388180555183835;
3389  Sigma[4] = 0.1843977014611545;
3390  Sigma[5] = 0.2271271152279254;
3391  Sigma[6] = 0.6985271697744179;
3392 
3393 
3394  // start test code //
3395  double eps = 1e-14;
3396  gensvm_kernel_trainfactor(data, P, Sigma, r);
3397  mu_assert(data->r == r, "Incorrect data->r");
3398 
3399  mu_assert(fabs(matrix_get(data->Z, r+1, 0, 0) -
3400  1.0000000000000000) < eps,
3401  "Incorrect data->Z at 0, 0");
3402  mu_assert(fabs(matrix_get(data->Z, r+1, 0, 1) -
3403  0.7183838977883847) < eps,
3404  "Incorrect data->Z at 0, 1");
3405  mu_assert(fabs(matrix_get(data->Z, r+1, 0, 2) -
3406  0.3630753280693996) < eps,
3407  "Incorrect data->Z at 0, 2");
3408  mu_assert(fabs(matrix_get(data->Z, r+1, 0, 3) -
3409  0.3247360589008871) < eps,
3410  "Incorrect data->Z at 0, 3");
3411  mu_assert(fabs(matrix_get(data->Z, r+1, 0, 4) -
3412  0.0319598137322927) < eps,
3413  "Incorrect data->Z at 0, 4");
3414  mu_assert(fabs(matrix_get(data->Z, r+1, 0, 5) -
3415  0.0503210788778667) < eps,
3416  "Incorrect data->Z at 0, 5");
3417  mu_assert(fabs(matrix_get(data->Z, r+1, 0, 6) -
3418  0.0958880494701488) < eps,
3419  "Incorrect data->Z at 0, 6");
3420  mu_assert(fabs(matrix_get(data->Z, r+1, 0, 7) -
3421  0.3555664378468590) < eps,
3422  "Incorrect data->Z at 0, 7");
3423  mu_assert(fabs(matrix_get(data->Z, r+1, 1, 0) -
3424  1.0000000000000000) < eps,
3425  "Incorrect data->Z at 1, 0");
3426  mu_assert(fabs(matrix_get(data->Z, r+1, 1, 1) -
3427  0.7080685113201802) < eps,
3428  "Incorrect data->Z at 1, 1");
3429  mu_assert(fabs(matrix_get(data->Z, r+1, 1, 2) -
3430  0.1386287648299510) < eps,
3431  "Incorrect data->Z at 1, 2");
3432  mu_assert(fabs(matrix_get(data->Z, r+1, 1, 3) -
3433  0.6176303419048280) < eps,
3434  "Incorrect data->Z at 1, 3");
3435  mu_assert(fabs(matrix_get(data->Z, r+1, 1, 4) -
3436  0.0308842988733590) < eps,
3437  "Incorrect data->Z at 1, 4");
3438  mu_assert(fabs(matrix_get(data->Z, r+1, 1, 5) -
3439  0.0491426957621803) < eps,
3440  "Incorrect data->Z at 1, 5");
3441  mu_assert(fabs(matrix_get(data->Z, r+1, 1, 6) -
3442  0.0376553169129896) < eps,
3443  "Incorrect data->Z at 1, 6");
3444  mu_assert(fabs(matrix_get(data->Z, r+1, 1, 7) -
3445  0.6287433205648071) < eps,
3446  "Incorrect data->Z at 1, 7");
3447  mu_assert(fabs(matrix_get(data->Z, r+1, 2, 0) -
3448  1.0000000000000000) < eps,
3449  "Incorrect data->Z at 2, 0");
3450  mu_assert(fabs(matrix_get(data->Z, r+1, 2, 1) -
3451  0.0262391769187446) < eps,
3452  "Incorrect data->Z at 2, 1");
3453  mu_assert(fabs(matrix_get(data->Z, r+1, 2, 2) -
3454  0.0180799608848456) < eps,
3455  "Incorrect data->Z at 2, 2");
3456  mu_assert(fabs(matrix_get(data->Z, r+1, 2, 3) -
3457  0.3674783177476025) < eps,
3458  "Incorrect data->Z at 2, 3");
3459  mu_assert(fabs(matrix_get(data->Z, r+1, 2, 4) -
3460  0.0224260721582540) < eps,
3461  "Incorrect data->Z at 2, 4");
3462  mu_assert(fabs(matrix_get(data->Z, r+1, 2, 5) -
3463  0.0207748861504618) < eps,
3464  "Incorrect data->Z at 2, 5");
3465  mu_assert(fabs(matrix_get(data->Z, r+1, 2, 6) -
3466  0.0561486769846686) < eps,
3467  "Incorrect data->Z at 2, 6");
3468  mu_assert(fabs(matrix_get(data->Z, r+1, 2, 7) -
3469  0.0796432387288058) < eps,
3470  "Incorrect data->Z at 2, 7");
3471  mu_assert(fabs(matrix_get(data->Z, r+1, 3, 0) -
3472  1.0000000000000000) < eps,
3473  "Incorrect data->Z at 3, 0");
3474  mu_assert(fabs(matrix_get(data->Z, r+1, 3, 1) -
3475  0.1557424369168406) < eps,
3476  "Incorrect data->Z at 3, 1");
3477  mu_assert(fabs(matrix_get(data->Z, r+1, 3, 2) -
3478  0.6805171738670187) < eps,
3479  "Incorrect data->Z at 3, 2");
3480  mu_assert(fabs(matrix_get(data->Z, r+1, 3, 3) -
3481  0.3843334233867928) < eps,
3482  "Incorrect data->Z at 3, 3");
3483  mu_assert(fabs(matrix_get(data->Z, r+1, 3, 4) -
3484  0.0171809905586351) < eps,
3485  "Incorrect data->Z at 3, 4");
3486  mu_assert(fabs(matrix_get(data->Z, r+1, 3, 5) -
3487  0.1766047611339114) < eps,
3488  "Incorrect data->Z at 3, 5");
3489  mu_assert(fabs(matrix_get(data->Z, r+1, 3, 6) -
3490  0.1814138840065695) < eps,
3491  "Incorrect data->Z at 3, 6");
3492  mu_assert(fabs(matrix_get(data->Z, r+1, 3, 7) -
3493  0.2738516231189423) < eps,
3494  "Incorrect data->Z at 3, 7");
3495  mu_assert(fabs(matrix_get(data->Z, r+1, 4, 0) -
3496  1.0000000000000000) < eps,
3497  "Incorrect data->Z at 4, 0");
3498  mu_assert(fabs(matrix_get(data->Z, r+1, 4, 1) -
3499  0.0019883976783969) < eps,
3500  "Incorrect data->Z at 4, 1");
3501  mu_assert(fabs(matrix_get(data->Z, r+1, 4, 2) -
3502  0.2810851060365751) < eps,
3503  "Incorrect data->Z at 4, 2");
3504  mu_assert(fabs(matrix_get(data->Z, r+1, 4, 3) -
3505  0.5841038474885426) < eps,
3506  "Incorrect data->Z at 4, 3");
3507  mu_assert(fabs(matrix_get(data->Z, r+1, 4, 4) -
3508  0.0298941904096380) < eps,
3509  "Incorrect data->Z at 4, 4");
3510  mu_assert(fabs(matrix_get(data->Z, r+1, 4, 5) -
3511  0.0815401544117791) < eps,
3512  "Incorrect data->Z at 4, 5");
3513  mu_assert(fabs(matrix_get(data->Z, r+1, 4, 6) -
3514  0.2217589161127987) < eps,
3515  "Incorrect data->Z at 4, 6");
3516  mu_assert(fabs(matrix_get(data->Z, r+1, 4, 7) -
3517  0.5403196600347527) < eps,
3518  "Incorrect data->Z at 4, 7");
3519  mu_assert(fabs(matrix_get(data->Z, r+1, 5, 0) -
3520  1.0000000000000000) < eps,
3521  "Incorrect data->Z at 5, 0");
3522  mu_assert(fabs(matrix_get(data->Z, r+1, 5, 1) -
3523  0.5919896235772685) < eps,
3524  "Incorrect data->Z at 5, 1");
3525  mu_assert(fabs(matrix_get(data->Z, r+1, 5, 2) -
3526  0.4817693948616519) < eps,
3527  "Incorrect data->Z at 5, 2");
3528  mu_assert(fabs(matrix_get(data->Z, r+1, 5, 3) -
3529  0.0317186243872882) < eps,
3530  "Incorrect data->Z at 5, 3");
3531  mu_assert(fabs(matrix_get(data->Z, r+1, 5, 4) -
3532  0.0126839697938067) < eps,
3533  "Incorrect data->Z at 5, 4");
3534  mu_assert(fabs(matrix_get(data->Z, r+1, 5, 5) -
3535  0.0736406799506745) < eps,
3536  "Incorrect data->Z at 5, 5");
3537  mu_assert(fabs(matrix_get(data->Z, r+1, 5, 6) -
3538  0.1157310446255655) < eps,
3539  "Incorrect data->Z at 5, 6");
3540  mu_assert(fabs(matrix_get(data->Z, r+1, 5, 7) -
3541  0.0305428687584698) < eps,
3542  "Incorrect data->Z at 5, 7");
3543  mu_assert(fabs(matrix_get(data->Z, r+1, 6, 0) -
3544  1.0000000000000000) < eps,
3545  "Incorrect data->Z at 6, 0");
3546  mu_assert(fabs(matrix_get(data->Z, r+1, 6, 1) -
3547  0.0687054523008138) < eps,
3548  "Incorrect data->Z at 6, 1");
3549  mu_assert(fabs(matrix_get(data->Z, r+1, 6, 2) -
3550  0.2755791613655394) < eps,
3551  "Incorrect data->Z at 6, 2");
3552  mu_assert(fabs(matrix_get(data->Z, r+1, 6, 3) -
3553  0.5734484174878248) < eps,
3554  "Incorrect data->Z at 6, 3");
3555  mu_assert(fabs(matrix_get(data->Z, r+1, 6, 4) -
3556  0.0143361879388834) < eps,
3557  "Incorrect data->Z at 6, 4");
3558  mu_assert(fabs(matrix_get(data->Z, r+1, 6, 5) -
3559  0.1684910230215461) < eps,
3560  "Incorrect data->Z at 6, 5");
3561  mu_assert(fabs(matrix_get(data->Z, r+1, 6, 6) -
3562  0.0270283280433711) < eps,
3563  "Incorrect data->Z at 6, 6");
3564  mu_assert(fabs(matrix_get(data->Z, r+1, 6, 7) -
3565  0.2469080974092735) < eps,
3566  "Incorrect data->Z at 6, 7");
3567  mu_assert(fabs(matrix_get(data->Z, r+1, 7, 0) -
3568  1.0000000000000000) < eps,
3569  "Incorrect data->Z at 7, 0");
3570  mu_assert(fabs(matrix_get(data->Z, r+1, 7, 1) -
3571  0.2394443715482110) < eps,
3572  "Incorrect data->Z at 7, 1");
3573  mu_assert(fabs(matrix_get(data->Z, r+1, 7, 2) -
3574  0.6361385405631184) < eps,
3575  "Incorrect data->Z at 7, 2");
3576  mu_assert(fabs(matrix_get(data->Z, r+1, 7, 3) -
3577  0.0705300837466403) < eps,
3578  "Incorrect data->Z at 7, 3");
3579  mu_assert(fabs(matrix_get(data->Z, r+1, 7, 4) -
3580  0.0095353696001854) < eps,
3581  "Incorrect data->Z at 7, 4");
3582  mu_assert(fabs(matrix_get(data->Z, r+1, 7, 5) -
3583  0.0035349835793759) < eps,
3584  "Incorrect data->Z at 7, 5");
3585  mu_assert(fabs(matrix_get(data->Z, r+1, 7, 6) -
3586  0.1183727026716577) < eps,
3587  "Incorrect data->Z at 7, 6");
3588  mu_assert(fabs(matrix_get(data->Z, r+1, 7, 7) -
3589  0.0674805012818914) < eps,
3590  "Incorrect data->Z at 7, 7");
3591  mu_assert(fabs(matrix_get(data->Z, r+1, 8, 0) -
3592  1.0000000000000000) < eps,
3593  "Incorrect data->Z at 8, 0");
3594  mu_assert(fabs(matrix_get(data->Z, r+1, 8, 1) -
3595  0.1037904837223778) < eps,
3596  "Incorrect data->Z at 8, 1");
3597  mu_assert(fabs(matrix_get(data->Z, r+1, 8, 2) -
3598  0.5711758028284341) < eps,
3599  "Incorrect data->Z at 8, 2");
3600  mu_assert(fabs(matrix_get(data->Z, r+1, 8, 3) -
3601  0.3669520858546538) < eps,
3602  "Incorrect data->Z at 8, 3");
3603  mu_assert(fabs(matrix_get(data->Z, r+1, 8, 4) -
3604  0.0042804583413615) < eps,
3605  "Incorrect data->Z at 8, 4");
3606  mu_assert(fabs(matrix_get(data->Z, r+1, 8, 5) -
3607  0.0890012756090077) < eps,
3608  "Incorrect data->Z at 8, 5");
3609  mu_assert(fabs(matrix_get(data->Z, r+1, 8, 6) -
3610  0.0565841273297056) < eps,
3611  "Incorrect data->Z at 8, 6");
3612  mu_assert(fabs(matrix_get(data->Z, r+1, 8, 7) -
3613  0.5083829794868514) < eps,
3614  "Incorrect data->Z at 8, 7");
3615  mu_assert(fabs(matrix_get(data->Z, r+1, 9, 0) -
3616  1.0000000000000000) < eps,
3617  "Incorrect data->Z at 9, 0");
3618  mu_assert(fabs(matrix_get(data->Z, r+1, 9, 1) -
3619  0.2042235187778177) < eps,
3620  "Incorrect data->Z at 9, 1");
3621  mu_assert(fabs(matrix_get(data->Z, r+1, 9, 2) -
3622  0.3279017337884026) < eps,
3623  "Incorrect data->Z at 9, 2");
3624  mu_assert(fabs(matrix_get(data->Z, r+1, 9, 3) -
3625  0.0645106520383707) < eps,
3626  "Incorrect data->Z at 9, 3");
3627  mu_assert(fabs(matrix_get(data->Z, r+1, 9, 4) -
3628  0.0336158008074787) < eps,
3629  "Incorrect data->Z at 9, 4");
3630  mu_assert(fabs(matrix_get(data->Z, r+1, 9, 5) -
3631  0.0189703601714739) < eps,
3632  "Incorrect data->Z at 9, 5");
3633  mu_assert(fabs(matrix_get(data->Z, r+1, 9, 6) -
3634  0.1405818916833765) < eps,
3635  "Incorrect data->Z at 9, 6");
3636  mu_assert(fabs(matrix_get(data->Z, r+1, 9, 7) -
3637  0.4815634079265663) < eps,
3638  "Incorrect data->Z at 9, 7");
3639 
3640  // end test code //
3641 
3642  free(Sigma);
3643  free(P);
3644  gensvm_free_data(data);
3645 
3646  return NULL;
3647 }
3648 
3649 char *test_kernel_testfactor()
3650 {
3651  struct GenData *test = gensvm_init_data();
3652  struct GenData *train = gensvm_init_data();
3653 
3654  int m = 3;
3655  train->n = 10;
3656  train->m = m;
3657  train->r = m;
3658  test->n = 5;
3659  test->m = m;
3660 
3661  train->Z = Calloc(double, train->n * (train->r + 1));
3662  train->Sigma = Calloc(double, train->r);
3663  double *K2 = Calloc(double, test->n * train->n);
3664 
3665  matrix_set(train->Z, train->r + 1, 0, 0, 1.0000000000000000);
3666  matrix_set(train->Z, train->r + 1, 0, 1, 0.8056271362589000);
3667  matrix_set(train->Z, train->r + 1, 0, 2, 0.4874175854113872);
3668  matrix_set(train->Z, train->r + 1, 0, 3, 0.4453015882771756);
3669  matrix_set(train->Z, train->r + 1, 1, 0, 1.0000000000000000);
3670  matrix_set(train->Z, train->r + 1, 1, 1, 0.7940590105180981);
3671  matrix_set(train->Z, train->r + 1, 1, 2, 0.1861049005485224);
3672  matrix_set(train->Z, train->r + 1, 1, 3, 0.8469394287449229);
3673  matrix_set(train->Z, train->r + 1, 2, 0, 1.0000000000000000);
3674  matrix_set(train->Z, train->r + 1, 2, 1, 0.0294257611061681);
3675  matrix_set(train->Z, train->r + 1, 2, 2, 0.0242717976065267);
3676  matrix_set(train->Z, train->r + 1, 2, 3, 0.5039128672814752);
3677  matrix_set(train->Z, train->r + 1, 3, 0, 1.0000000000000000);
3678  matrix_set(train->Z, train->r + 1, 3, 1, 0.1746563833537603);
3679  matrix_set(train->Z, train->r + 1, 3, 2, 0.9135736087631979);
3680  matrix_set(train->Z, train->r + 1, 3, 3, 0.5270258081021366);
3681  matrix_set(train->Z, train->r + 1, 4, 0, 1.0000000000000000);
3682  matrix_set(train->Z, train->r + 1, 4, 1, 0.0022298761599785);
3683  matrix_set(train->Z, train->r + 1, 4, 2, 0.3773482059713607);
3684  matrix_set(train->Z, train->r + 1, 4, 3, 0.8009654729622842);
3685  matrix_set(train->Z, train->r + 1, 5, 0, 1.0000000000000000);
3686  matrix_set(train->Z, train->r + 1, 5, 1, 0.6638830667081945);
3687  matrix_set(train->Z, train->r + 1, 5, 2, 0.6467607601353914);
3688  matrix_set(train->Z, train->r + 1, 5, 3, 0.0434948735457108);
3689  matrix_set(train->Z, train->r + 1, 6, 0, 1.0000000000000000);
3690  matrix_set(train->Z, train->r + 1, 6, 1, 0.0770493004546461);
3691  matrix_set(train->Z, train->r + 1, 6, 2, 0.3699566427075194);
3692  matrix_set(train->Z, train->r + 1, 6, 3, 0.7863539761080217);
3693  matrix_set(train->Z, train->r + 1, 7, 0, 1.0000000000000000);
3694  matrix_set(train->Z, train->r + 1, 7, 1, 0.2685233952731509);
3695  matrix_set(train->Z, train->r + 1, 7, 2, 0.8539966432782011);
3696  matrix_set(train->Z, train->r + 1, 7, 3, 0.0967159557826836);
3697  matrix_set(train->Z, train->r + 1, 8, 0, 1.0000000000000000);
3698  matrix_set(train->Z, train->r + 1, 8, 1, 0.1163951898554611);
3699  matrix_set(train->Z, train->r + 1, 8, 2, 0.7667861436369238);
3700  matrix_set(train->Z, train->r + 1, 8, 3, 0.5031912600213351);
3701  matrix_set(train->Z, train->r + 1, 9, 0, 1.0000000000000000);
3702  matrix_set(train->Z, train->r + 1, 9, 1, 0.2290251898688216);
3703  matrix_set(train->Z, train->r + 1, 9, 2, 0.4401981048538806);
3704  matrix_set(train->Z, train->r + 1, 9, 3, 0.0884616753393881);
3705 
3706  train->Sigma[0] = 0.3385406475521640;
3707  train->Sigma[1] = 0.6866094956337303;
3708  train->Sigma[2] = 0.2520805490786355;
3709 
3710  matrix_set(K2, train->n, 0, 0, 0.8233234072519983);
3711  matrix_set(K2, train->n, 0, 1, 0.3267543833513200);
3712  matrix_set(K2, train->n, 0, 2, 0.2728942849022845);
3713  matrix_set(K2, train->n, 0, 3, 0.3993579061297995);
3714  matrix_set(K2, train->n, 0, 4, 0.4221779040953508);
3715  matrix_set(K2, train->n, 0, 5, 0.5095430570208566);
3716  matrix_set(K2, train->n, 0, 6, 0.5090230605656835);
3717  matrix_set(K2, train->n, 0, 7, 0.0437246682449493);
3718  matrix_set(K2, train->n, 0, 8, 0.8917076715220298);
3719  matrix_set(K2, train->n, 0, 9, 0.2271271152279254);
3720  matrix_set(K2, train->n, 1, 0, 0.7956168453294307);
3721  matrix_set(K2, train->n, 1, 1, 0.3693175185473680);
3722  matrix_set(K2, train->n, 1, 2, 0.2665038412777220);
3723  matrix_set(K2, train->n, 1, 3, 0.9137371110726166);
3724  matrix_set(K2, train->n, 1, 4, 0.1657896146622650);
3725  matrix_set(K2, train->n, 1, 5, 0.1190008864254177);
3726  matrix_set(K2, train->n, 1, 6, 0.9000985899630121);
3727  matrix_set(K2, train->n, 1, 7, 0.3534695686769205);
3728  matrix_set(K2, train->n, 1, 8, 0.7448958325189663);
3729  matrix_set(K2, train->n, 1, 9, 0.6985271697744179);
3730  matrix_set(K2, train->n, 2, 0, 0.5777227081256917);
3731  matrix_set(K2, train->n, 2, 1, 0.2456426390463990);
3732  matrix_set(K2, train->n, 2, 2, 0.1126634767453339);
3733  matrix_set(K2, train->n, 2, 3, 0.0191704319054138);
3734  matrix_set(K2, train->n, 2, 4, 0.2472125660924395);
3735  matrix_set(K2, train->n, 2, 5, 0.5211738041619068);
3736  matrix_set(K2, train->n, 2, 6, 0.1140159498084029);
3737  matrix_set(K2, train->n, 2, 7, 0.0966039750517987);
3738  matrix_set(K2, train->n, 2, 8, 0.7292497207505059);
3739  matrix_set(K2, train->n, 2, 9, 0.3663483426181376);
3740  matrix_set(K2, train->n, 3, 0, 0.4426030703804438);
3741  matrix_set(K2, train->n, 3, 1, 0.1102697774064020);
3742  matrix_set(K2, train->n, 3, 2, 0.9577384085295405);
3743  matrix_set(K2, train->n, 3, 3, 0.4826593547737735);
3744  matrix_set(K2, train->n, 3, 4, 0.7987328321610475);
3745  matrix_set(K2, train->n, 3, 5, 0.2491297759535341);
3746  matrix_set(K2, train->n, 3, 6, 0.3920414766506218);
3747  matrix_set(K2, train->n, 3, 7, 0.7277927065471604);
3748  matrix_set(K2, train->n, 3, 8, 0.0388180555183835);
3749  matrix_set(K2, train->n, 3, 9, 0.0724688230975385);
3750  matrix_set(K2, train->n, 4, 0, 0.7701104553132680);
3751  matrix_set(K2, train->n, 4, 1, 0.8659836346403005);
3752  matrix_set(K2, train->n, 4, 2, 0.4421972387164297);
3753  matrix_set(K2, train->n, 4, 3, 0.1028774221216107);
3754  matrix_set(K2, train->n, 4, 4, 0.9763647809741268);
3755  matrix_set(K2, train->n, 4, 5, 0.6189568847484389);
3756  matrix_set(K2, train->n, 4, 6, 0.7735127328107272);
3757  matrix_set(K2, train->n, 4, 7, 0.6893982492936992);
3758  matrix_set(K2, train->n, 4, 8, 0.1843977014611545);
3759  matrix_set(K2, train->n, 4, 9, 0.5028223670359105);
3760 
3761  // start test code //
3762  double eps = 1e-14;
3763  gensvm_kernel_testfactor(test, train, K2);
3764  mu_assert(test->r == train->r, "Incorrect test->r");
3765 
3766  mu_assert(fabs(matrix_get(test->Z, test->r+1, 0, 0) -
3767  1.0000000000000000) < eps,
3768  "Incorrect test->Z at 0, 0");
3769  mu_assert(fabs(matrix_get(test->Z, test->r+1, 0, 1) -
3770  13.4938074073234233) < eps,
3771  "Incorrect test->Z at 0, 1");
3772  mu_assert(fabs(matrix_get(test->Z, test->r+1, 0, 2) -
3773  4.9462576505461318) < eps,
3774  "Incorrect test->Z at 0, 2");
3775  mu_assert(fabs(matrix_get(test->Z, test->r+1, 0, 3) -
3776  35.0141524482092095) < eps,
3777  "Incorrect test->Z at 0, 3");
3778  mu_assert(fabs(matrix_get(test->Z, test->r+1, 1, 0) -
3779  1.0000000000000000) < eps,
3780  "Incorrect test->Z at 1, 0");
3781  mu_assert(fabs(matrix_get(test->Z, test->r+1, 1, 1) -
3782  13.8904764364627322) < eps,
3783  "Incorrect test->Z at 1, 1");
3784  mu_assert(fabs(matrix_get(test->Z, test->r+1, 1, 2) -
3785  6.2592510920597659) < eps,
3786  "Incorrect test->Z at 1, 2");
3787  mu_assert(fabs(matrix_get(test->Z, test->r+1, 1, 3) -
3788  40.9083467283112441) < eps,
3789  "Incorrect test->Z at 1, 3");
3790  mu_assert(fabs(matrix_get(test->Z, test->r+1, 2, 0) -
3791  1.0000000000000000) < eps,
3792  "Incorrect test->Z at 2, 0");
3793  mu_assert(fabs(matrix_get(test->Z, test->r+1, 2, 1) -
3794  10.6204422184756044) < eps,
3795  "Incorrect test->Z at 2, 1");
3796  mu_assert(fabs(matrix_get(test->Z, test->r+1, 2, 2) -
3797  3.4427837480556240) < eps,
3798  "Incorrect test->Z at 2, 2");
3799  mu_assert(fabs(matrix_get(test->Z, test->r+1, 2, 3) -
3800  19.6903927993336545) < eps,
3801  "Incorrect test->Z at 2, 3");
3802  mu_assert(fabs(matrix_get(test->Z, test->r+1, 3, 0) -
3803  1.0000000000000000) < eps,
3804  "Incorrect test->Z at 3, 0");
3805  mu_assert(fabs(matrix_get(test->Z, test->r+1, 3, 1) -
3806  8.4682213303174958) < eps,
3807  "Incorrect test->Z at 3, 1");
3808  mu_assert(fabs(matrix_get(test->Z, test->r+1, 3, 2) -
3809  4.2237417955914749) < eps,
3810  "Incorrect test->Z at 3, 2");
3811  mu_assert(fabs(matrix_get(test->Z, test->r+1, 3, 3) -
3812  32.7751478586422280) < eps,
3813  "Incorrect test->Z at 3, 3");
3814  mu_assert(fabs(matrix_get(test->Z, test->r+1, 4, 0) -
3815  1.0000000000000000) < eps,
3816  "Incorrect test->Z at 4, 0");
3817  mu_assert(fabs(matrix_get(test->Z, test->r+1, 4, 1) -
3818  18.6151364859121280) < eps,
3819  "Incorrect test->Z at 4, 1");
3820  mu_assert(fabs(matrix_get(test->Z, test->r+1, 4, 2) -
3821  5.6161575228997469) < eps,
3822  "Incorrect test->Z at 4, 2");
3823  mu_assert(fabs(matrix_get(test->Z, test->r+1, 4, 3) -
3824  46.8107321811939130) < eps,
3825  "Incorrect test->Z at 4, 3");
3826 
3827  // end test code //
3828 
3829  free(K2);
3830 
3831  gensvm_free_data(test);
3832  gensvm_free_data(train);
3833 
3834  return NULL;
3835 }
3836 
3837 char *test_dsyevx()
3838 {
3839  mu_test_missing();
3840 
3841  return NULL;
3842 }
3843 
3844 char *test_dlamch()
3845 {
3846  mu_test_missing();
3847 
3848  return NULL;
3849 }
3850 
3851 char *all_tests()
3852 {
3853  mu_suite_start();
3854  mu_run_test(test_dot_rbf);
3855  mu_run_test(test_dot_poly);
3856  mu_run_test(test_dot_sigmoid);
3857 
3858  mu_run_test(test_kernel_preprocess_linear);
3859  mu_run_test(test_kernel_preprocess_kernel);
3860 
3861  mu_run_test(test_kernel_copy_kernelparam_to_data_linear);
3862  mu_run_test(test_kernel_copy_kernelparam_to_data_rbf);
3863  mu_run_test(test_kernel_copy_kernelparam_to_data_poly);
3864  mu_run_test(test_kernel_copy_kernelparam_to_data_sigmoid);
3865 
3866  mu_run_test(test_kernel_postprocess_linear);
3867  mu_run_test(test_kernel_postprocess_kernel);
3868 
3869  mu_run_test(test_kernel_compute_rbf);
3870  mu_run_test(test_kernel_compute_poly);
3871  mu_run_test(test_kernel_compute_sigmoid);
3872 
3873  mu_run_test(test_kernel_eigendecomp);
3874 
3875  mu_run_test(test_kernel_cross_rbf);
3876  mu_run_test(test_kernel_cross_poly);
3877  mu_run_test(test_kernel_cross_sigmoid);
3878 
3879  mu_run_test(test_kernel_trainfactor);
3880 
3881  mu_run_test(test_kernel_testfactor);
3882 
3883  return NULL;
3884 }
3885 
3886 RUN_TESTS(all_tests);
minunit.h
Minimal unit testing framework for C.
Calloc
#define Calloc(type, size)
Definition: gensvm_memory.h:40
K_LINEAR
Definition: gensvm_globals.h:68
GenData::gamma
double gamma
kernel parameter for RBF, poly, and sigmoid
Definition: gensvm_base.h:80
test_kernel_cross_poly
char * test_kernel_cross_poly()
Definition: test_gensvm_kernel.c:2805
gensvm_kernel_copy_kernelparam_to_data
void gensvm_kernel_copy_kernelparam_to_data(struct GenModel *model, struct GenData *data)
Copy the kernelparameters from GenModel to GenData.
Definition: gensvm_kernel.c:46
test_kernel_preprocess_linear
char * test_kernel_preprocess_linear()
Definition: test_gensvm_kernel.c:227
test_kernel_copy_kernelparam_to_data_rbf
char * test_kernel_copy_kernelparam_to_data_rbf()
Definition: test_gensvm_kernel.c:50
test_dot_rbf
char * test_dot_rbf()
Definition: test_gensvm_kernel.c:119
test_kernel_postprocess_kernel
char * test_kernel_postprocess_kernel()
Definition: test_gensvm_kernel.c:786
mu_assert
#define mu_assert(test, message)
Definition: minunit.h:29
GenData::K
long K
number of classes
Definition: gensvm_base.h:58
test_kernel_cross_sigmoid
char * test_kernel_cross_sigmoid()
Definition: test_gensvm_kernel.c:3053
test_kernel_eigendecomp
char * test_kernel_eigendecomp()
Definition: test_gensvm_kernel.c:2206
gensvm_kernel_dot_rbf
double gensvm_kernel_dot_rbf(double *x1, double *x2, long n, double gamma)
Compute the RBF kernel between two vectors.
Definition: gensvm_kernel.c:472
matrix_get
#define matrix_get(M, cols, i, j)
Definition: gensvm_globals.h:111
GenData::degree
double degree
kernel parameter for poly
Definition: gensvm_base.h:84
RUN_TESTS
RUN_TESTS(all_tests)
GenData::Z
double * Z
Definition: gensvm_base.h:68
gensvm_free_model
void gensvm_free_model(struct GenModel *model)
Free allocated GenModel struct.
Definition: gensvm_base.c:211
test_kernel_copy_kernelparam_to_data_sigmoid
char * test_kernel_copy_kernelparam_to_data_sigmoid()
Definition: test_gensvm_kernel.c:96
gensvm_kernel_compute
void gensvm_kernel_compute(struct GenModel *model, struct GenData *data, double *K)
Compute the kernel matrix.
Definition: gensvm_kernel.c:157
Malloc
#define Malloc(type, size)
Definition: gensvm_memory.h:48
mu_run_test
#define mu_run_test(test)
Definition: minunit.h:35
test_dsyevx
char * test_dsyevx()
Definition: test_gensvm_kernel.c:3837
gensvm_init_model
struct GenModel * gensvm_init_model(void)
Initialize a GenModel structure.
Definition: gensvm_base.c:102
test_kernel_compute_sigmoid
char * test_kernel_compute_sigmoid()
Definition: test_gensvm_kernel.c:1831
GenData
A structure to represent the data.
Definition: gensvm_base.h:57
GenModel
A structure to represent a single GenSVM model.
Definition: gensvm_base.h:92
K_RBF
Definition: gensvm_globals.h:70
gensvm_kernel.h
Header file for gensvm_kernel.c.
gensvm_kernel_cross
double * gensvm_kernel_cross(struct GenModel *model, struct GenData *data_train, struct GenData *data_test)
Compute the kernel crossproduct between two datasets.
Definition: gensvm_kernel.c:311
GenData::kerneltype
KernelType kerneltype
Definition: gensvm_base.h:77
all_tests
char * all_tests()
Definition: test_gensvm_kernel.c:3851
mu_test_missing
#define mu_test_missing()
Definition: minunit.h:60
GenData::Sigma
double * Sigma
eigenvalues from the reduced eigendecomposition
Definition: gensvm_base.h:75
test_dot_sigmoid
char * test_dot_sigmoid()
Definition: test_gensvm_kernel.c:190
GenModel::n
long n
number of instances in the dataset
Definition: gensvm_base.h:97
test_kernel_trainfactor
char * test_kernel_trainfactor()
Definition: test_gensvm_kernel.c:3302
gensvm_kernel_eigendecomp
long gensvm_kernel_eigendecomp(double *K, long n, double cutoff, double **P_ret, double **Sigma_ret)
Find the (reduced) eigendecomposition of a kernel matrix.
Definition: gensvm_kernel.c:215
K_POLY
Definition: gensvm_globals.h:69
test_kernel_copy_kernelparam_to_data_poly
char * test_kernel_copy_kernelparam_to_data_poly()
Definition: test_gensvm_kernel.c:71
gensvm_kernel_testfactor
void gensvm_kernel_testfactor(struct GenData *testdata, struct GenData *traindata, double *K2)
Calculate the matrix product for the testfactor.
Definition: gensvm_kernel.c:406
gensvm_free_data
void gensvm_free_data(struct GenData *data)
Free allocated GenData struct.
Definition: gensvm_base.c:73
test_kernel_cross_rbf
char * test_kernel_cross_rbf()
Definition: test_gensvm_kernel.c:2559
gensvm_kernel_trainfactor
void gensvm_kernel_trainfactor(struct GenData *data, double *P, double *Sigma, long r)
Compute the training factor as part of kernel preprocessing.
Definition: gensvm_kernel.c:365
test_dot_poly
char * test_dot_poly()
Definition: test_gensvm_kernel.c:153
GenData::r
long r
number of eigenvalues (width of Z)
Definition: gensvm_base.h:64
K_SIGMOID
Definition: gensvm_globals.h:71
gensvm_kernel_dot_sigmoid
double gensvm_kernel_dot_sigmoid(double *x1, double *x2, long n, double gamma, double coef)
Compute the sigmoid kernel between two vectors.
Definition: gensvm_kernel.c:530
test_dlamch
char * test_dlamch()
Definition: test_gensvm_kernel.c:3844
test_kernel_copy_kernelparam_to_data_linear
char * test_kernel_copy_kernelparam_to_data_linear()
Definition: test_gensvm_kernel.c:30
GenModel::degree
double degree
kernel parameter for poly
Definition: gensvm_base.h:113
GenData::m
long m
number of predictors (width of RAW)
Definition: gensvm_base.h:62
GenModel::coef
double coef
kernel parameter for poly and sigmoid
Definition: gensvm_base.h:111
test_kernel_compute_rbf
char * test_kernel_compute_rbf()
Definition: test_gensvm_kernel.c:1082
matrix_set
#define matrix_set(M, cols, i, j, val)
Definition: gensvm_globals.h:106
GenModel::kerneltype
KernelType kerneltype
type of kernel used in the model
Definition: gensvm_base.h:136
GenModel::gamma
double gamma
kernel parameter for RBF, poly, and sigmoid
Definition: gensvm_base.h:109
GenData::coef
double coef
kernel parameter for poly and sigmoid
Definition: gensvm_base.h:82
gensvm_kernel_postprocess
void gensvm_kernel_postprocess(struct GenModel *model, struct GenData *traindata, struct GenData *testdata)
Compute the kernel postprocessing factor.
Definition: gensvm_kernel.c:125
GenData::n
long n
number of instances
Definition: gensvm_base.h:60
gensvm_kernel_dot_poly
double gensvm_kernel_dot_poly(double *x1, double *x2, long n, double gamma, double coef, double degree)
Compute the polynomial kernel between two vectors.
Definition: gensvm_kernel.c:503
test_kernel_compute_poly
char * test_kernel_compute_poly()
Definition: test_gensvm_kernel.c:1456
test_kernel_postprocess_linear
char * test_kernel_postprocess_linear()
Definition: test_gensvm_kernel.c:762
gensvm_init_data
struct GenData * gensvm_init_data(void)
Initialize a GenData structure.
Definition: gensvm_base.c:45
GenModel::m
long m
number of predictor variables in the dataset
Definition: gensvm_base.h:99
mu_suite_start
#define mu_suite_start()
Definition: minunit.h:24
GenData::RAW
double * RAW
augmented raw data matrix
Definition: gensvm_base.h:73
gensvm_kernel_preprocess
void gensvm_kernel_preprocess(struct GenModel *model, struct GenData *data)
Do the preprocessing steps needed to perform kernel GenSVM.
Definition: gensvm_kernel.c:75
GenModel::kernel_eigen_cutoff
double kernel_eigen_cutoff
cutoff value for the ratio of eigenvalues in the reduced
Definition: gensvm_base.h:138
test_kernel_testfactor
char * test_kernel_testfactor()
Definition: test_gensvm_kernel.c:3649
test_kernel_preprocess_kernel
char * test_kernel_preprocess_kernel()
Definition: test_gensvm_kernel.c:245
Generated on Tue Feb 21 2017 18:44:21 for GenSVM by   doxygen 1.8.13