GenSVM
test_gensvm_gridsearch.c
Go to the documentation of this file.
1 
27 #include "minunit.h"
28 #include "gensvm_gridsearch.h"
29 
30 extern FILE *GENSVM_OUTPUT_FILE;
31 
32 char *test_fill_queue_nokernel()
33 {
34  struct GenData *train_data = gensvm_init_data();
35  struct GenData *test_data = gensvm_init_data();
36  struct GenGrid *grid = gensvm_init_grid();
37 
38  grid->Np = 3;
39  grid->Nl = 2;
40  grid->Nk = 1;
41  grid->Ne = 1;
42  grid->Nw = 1;
43 
44  grid->ps = Calloc(double, grid->Np);
45  grid->ps[0] = 1.0;
46  grid->ps[1] = 1.5;
47  grid->ps[2] = 2.0;
48 
49  grid->lambdas = Calloc(double, grid->Nl);
50  grid->lambdas[0] = 1.0;
51  grid->lambdas[1] = 5.0;
52 
53  grid->kappas = Calloc(double, grid->Nk);
54  grid->kappas[0] = -0.99;
55 
56  grid->epsilons = Calloc(double, grid->Ne);
57  grid->epsilons[0] = 1e-6;
58 
59  grid->weight_idxs = Calloc(double, grid->Nw);
60  grid->weight_idxs[0] = 1;
61 
62  // start test code //
63  struct GenQueue *q = gensvm_init_queue();
64  gensvm_fill_queue(grid, q, train_data, test_data);
65 
66  mu_assert(q->N == 6, "Incorrect number of queue elements");
67 
68  int i;
69  for (i=0; i<q->N; i++) {
70  mu_assert(q->tasks[i]->ID == i, "Incorrect ID");
71  mu_assert(q->tasks[i]->folds == 10, "Incorrect folds");
72  mu_assert(q->tasks[i]->kerneltype == K_LINEAR,
73  "Incorrect kernel type");
74  mu_assert(q->tasks[i]->train_data == train_data,
75  "Incorrect train_data");
76  mu_assert(q->tasks[i]->test_data == test_data,
77  "Incorrect test data")
78  }
79 
80  // test p value
81  mu_assert(q->tasks[0]->p == 1.0, "Incorrect p at task 0");
82  mu_assert(q->tasks[1]->p == 1.5, "Incorrect p at task 1");
83  mu_assert(q->tasks[2]->p == 2.0, "Incorrect p at task 2");
84  mu_assert(q->tasks[3]->p == 1.0, "Incorrect p at task 3");
85  mu_assert(q->tasks[4]->p == 1.5, "Incorrect p at task 4");
86  mu_assert(q->tasks[5]->p == 2.0, "Incorrect p at task 5");
87 
88  // test lambda value
89  mu_assert(q->tasks[0]->lambda == 1.0, "Incorrect lambda at task 0");
90  mu_assert(q->tasks[1]->lambda == 1.0, "Incorrect lambda at task 1");
91  mu_assert(q->tasks[2]->lambda == 1.0, "Incorrect lambda at task 2");
92  mu_assert(q->tasks[3]->lambda == 5.0, "Incorrect lambda at task 3");
93  mu_assert(q->tasks[4]->lambda == 5.0, "Incorrect lambda at task 4");
94  mu_assert(q->tasks[5]->lambda == 5.0, "Incorrect lambda at task 5");
95 
96  // test kappa value
97  mu_assert(q->tasks[0]->kappa == -0.99, "Incorrect kappa at task 0");
98  mu_assert(q->tasks[1]->kappa == -0.99, "Incorrect kappa at task 1");
99  mu_assert(q->tasks[2]->kappa == -0.99, "Incorrect kappa at task 2");
100  mu_assert(q->tasks[3]->kappa == -0.99, "Incorrect kappa at task 3");
101  mu_assert(q->tasks[4]->kappa == -0.99, "Incorrect kappa at task 4");
102  mu_assert(q->tasks[5]->kappa == -0.99, "Incorrect kappa at task 5");
103 
104  // test epsilon value
105  mu_assert(q->tasks[0]->epsilon == 1e-6, "Incorrect epsilon at task 0");
106  mu_assert(q->tasks[1]->epsilon == 1e-6, "Incorrect epsilon at task 1");
107  mu_assert(q->tasks[2]->epsilon == 1e-6, "Incorrect epsilon at task 2");
108  mu_assert(q->tasks[3]->epsilon == 1e-6, "Incorrect epsilon at task 3");
109  mu_assert(q->tasks[4]->epsilon == 1e-6, "Incorrect epsilon at task 4");
110  mu_assert(q->tasks[5]->epsilon == 1e-6, "Incorrect epsilon at task 5");
111 
112  gensvm_free_queue(q);
113  // end test code //
114 
115  gensvm_free_data(train_data);
116  gensvm_free_data(test_data);
117  gensvm_free_grid(grid);
118 
119  return NULL;
120 }
121 
122 char *test_fill_queue_kernel()
123 {
124  struct GenData *train_data = gensvm_init_data();
125  struct GenData *test_data = gensvm_init_data();
126  struct GenGrid *grid = gensvm_init_grid();
127 
128  grid->kerneltype = K_POLY;
129  grid->Np = 3;
130  grid->Nl = 2;
131  grid->Nk = 1;
132  grid->Ne = 1;
133  grid->Nw = 1;
134  grid->Ng = 2;
135  grid->Nc = 3;
136  grid->Nd = 2;
137 
138  grid->ps = Calloc(double, grid->Np);
139  grid->ps[0] = 1.0;
140  grid->ps[1] = 1.5;
141  grid->ps[2] = 2.0;
142 
143  grid->lambdas = Calloc(double, grid->Nl);
144  grid->lambdas[0] = 1.0;
145  grid->lambdas[1] = 5.0;
146 
147  grid->kappas = Calloc(double, grid->Nk);
148  grid->kappas[0] = -0.99;
149 
150  grid->epsilons = Calloc(double, grid->Ne);
151  grid->epsilons[0] = 1e-6;
152 
153  grid->weight_idxs = Calloc(double, grid->Nw);
154  grid->weight_idxs[0] = 1;
155 
156  grid->gammas = Calloc(double, grid->Ng);
157  grid->gammas[0] = 0.5;
158  grid->gammas[1] = 1.5;
159 
160  grid->coefs = Calloc(double, grid->Nc);
161  grid->coefs[0] = 7.0;
162  grid->coefs[1] = 11.0;
163  grid->coefs[2] = 13.0;
164 
165  grid->degrees = Calloc(double, grid->Nd);
166  grid->degrees[0] = 3.0;
167  grid->degrees[1] = 5.0;
168 
169  // start test code //
170  struct GenQueue *q = gensvm_init_queue();
171  gensvm_fill_queue(grid, q, train_data, test_data);
172 
173  mu_assert(q->N == 72, "Incorrect number of queue elements");
174 
175  int i;
176  for (i=0; i<q->N; i++) {
177  mu_assert(q->tasks[i]->ID == i, "Incorrect ID");
178  mu_assert(q->tasks[i]->folds == 10, "Incorrect folds");
179  mu_assert(q->tasks[i]->kerneltype == K_POLY,
180  "Incorrect kernel type");
181  mu_assert(q->tasks[i]->train_data == train_data,
182  "Incorrect train_data");
183  mu_assert(q->tasks[i]->test_data == test_data,
184  "Incorrect test data");
185  mu_assert(q->tasks[i]->weight_idx == 1,
186  "Incorrect weight idx");
187  mu_assert(q->tasks[i]->epsilon == 1e-6,
188  "Incorrect epsilon");
189  mu_assert(q->tasks[i]->kappa == -0.99,
190  "Incorrect kappa");
191  }
192 
193  mu_assert(q->tasks[0]->p == 1.000000, "Incorrect p at task 0");
194  mu_assert(q->tasks[1]->p == 1.500000, "Incorrect p at task 1");
195  mu_assert(q->tasks[2]->p == 2.000000, "Incorrect p at task 2");
196  mu_assert(q->tasks[3]->p == 1.000000, "Incorrect p at task 3");
197  mu_assert(q->tasks[4]->p == 1.500000, "Incorrect p at task 4");
198  mu_assert(q->tasks[5]->p == 2.000000, "Incorrect p at task 5");
199  mu_assert(q->tasks[6]->p == 1.000000, "Incorrect p at task 6");
200  mu_assert(q->tasks[7]->p == 1.500000, "Incorrect p at task 7");
201  mu_assert(q->tasks[8]->p == 2.000000, "Incorrect p at task 8");
202  mu_assert(q->tasks[9]->p == 1.000000, "Incorrect p at task 9");
203  mu_assert(q->tasks[10]->p == 1.500000, "Incorrect p at task 10");
204  mu_assert(q->tasks[11]->p == 2.000000, "Incorrect p at task 11");
205  mu_assert(q->tasks[12]->p == 1.000000, "Incorrect p at task 12");
206  mu_assert(q->tasks[13]->p == 1.500000, "Incorrect p at task 13");
207  mu_assert(q->tasks[14]->p == 2.000000, "Incorrect p at task 14");
208  mu_assert(q->tasks[15]->p == 1.000000, "Incorrect p at task 15");
209  mu_assert(q->tasks[16]->p == 1.500000, "Incorrect p at task 16");
210  mu_assert(q->tasks[17]->p == 2.000000, "Incorrect p at task 17");
211  mu_assert(q->tasks[18]->p == 1.000000, "Incorrect p at task 18");
212  mu_assert(q->tasks[19]->p == 1.500000, "Incorrect p at task 19");
213  mu_assert(q->tasks[20]->p == 2.000000, "Incorrect p at task 20");
214  mu_assert(q->tasks[21]->p == 1.000000, "Incorrect p at task 21");
215  mu_assert(q->tasks[22]->p == 1.500000, "Incorrect p at task 22");
216  mu_assert(q->tasks[23]->p == 2.000000, "Incorrect p at task 23");
217  mu_assert(q->tasks[24]->p == 1.000000, "Incorrect p at task 24");
218  mu_assert(q->tasks[25]->p == 1.500000, "Incorrect p at task 25");
219  mu_assert(q->tasks[26]->p == 2.000000, "Incorrect p at task 26");
220  mu_assert(q->tasks[27]->p == 1.000000, "Incorrect p at task 27");
221  mu_assert(q->tasks[28]->p == 1.500000, "Incorrect p at task 28");
222  mu_assert(q->tasks[29]->p == 2.000000, "Incorrect p at task 29");
223  mu_assert(q->tasks[30]->p == 1.000000, "Incorrect p at task 30");
224  mu_assert(q->tasks[31]->p == 1.500000, "Incorrect p at task 31");
225  mu_assert(q->tasks[32]->p == 2.000000, "Incorrect p at task 32");
226  mu_assert(q->tasks[33]->p == 1.000000, "Incorrect p at task 33");
227  mu_assert(q->tasks[34]->p == 1.500000, "Incorrect p at task 34");
228  mu_assert(q->tasks[35]->p == 2.000000, "Incorrect p at task 35");
229  mu_assert(q->tasks[36]->p == 1.000000, "Incorrect p at task 36");
230  mu_assert(q->tasks[37]->p == 1.500000, "Incorrect p at task 37");
231  mu_assert(q->tasks[38]->p == 2.000000, "Incorrect p at task 38");
232  mu_assert(q->tasks[39]->p == 1.000000, "Incorrect p at task 39");
233  mu_assert(q->tasks[40]->p == 1.500000, "Incorrect p at task 40");
234  mu_assert(q->tasks[41]->p == 2.000000, "Incorrect p at task 41");
235  mu_assert(q->tasks[42]->p == 1.000000, "Incorrect p at task 42");
236  mu_assert(q->tasks[43]->p == 1.500000, "Incorrect p at task 43");
237  mu_assert(q->tasks[44]->p == 2.000000, "Incorrect p at task 44");
238  mu_assert(q->tasks[45]->p == 1.000000, "Incorrect p at task 45");
239  mu_assert(q->tasks[46]->p == 1.500000, "Incorrect p at task 46");
240  mu_assert(q->tasks[47]->p == 2.000000, "Incorrect p at task 47");
241  mu_assert(q->tasks[48]->p == 1.000000, "Incorrect p at task 48");
242  mu_assert(q->tasks[49]->p == 1.500000, "Incorrect p at task 49");
243  mu_assert(q->tasks[50]->p == 2.000000, "Incorrect p at task 50");
244  mu_assert(q->tasks[51]->p == 1.000000, "Incorrect p at task 51");
245  mu_assert(q->tasks[52]->p == 1.500000, "Incorrect p at task 52");
246  mu_assert(q->tasks[53]->p == 2.000000, "Incorrect p at task 53");
247  mu_assert(q->tasks[54]->p == 1.000000, "Incorrect p at task 54");
248  mu_assert(q->tasks[55]->p == 1.500000, "Incorrect p at task 55");
249  mu_assert(q->tasks[56]->p == 2.000000, "Incorrect p at task 56");
250  mu_assert(q->tasks[57]->p == 1.000000, "Incorrect p at task 57");
251  mu_assert(q->tasks[58]->p == 1.500000, "Incorrect p at task 58");
252  mu_assert(q->tasks[59]->p == 2.000000, "Incorrect p at task 59");
253  mu_assert(q->tasks[60]->p == 1.000000, "Incorrect p at task 60");
254  mu_assert(q->tasks[61]->p == 1.500000, "Incorrect p at task 61");
255  mu_assert(q->tasks[62]->p == 2.000000, "Incorrect p at task 62");
256  mu_assert(q->tasks[63]->p == 1.000000, "Incorrect p at task 63");
257  mu_assert(q->tasks[64]->p == 1.500000, "Incorrect p at task 64");
258  mu_assert(q->tasks[65]->p == 2.000000, "Incorrect p at task 65");
259  mu_assert(q->tasks[66]->p == 1.000000, "Incorrect p at task 66");
260  mu_assert(q->tasks[67]->p == 1.500000, "Incorrect p at task 67");
261  mu_assert(q->tasks[68]->p == 2.000000, "Incorrect p at task 68");
262  mu_assert(q->tasks[69]->p == 1.000000, "Incorrect p at task 69");
263  mu_assert(q->tasks[70]->p == 1.500000, "Incorrect p at task 70");
264  mu_assert(q->tasks[71]->p == 2.000000, "Incorrect p at task 71");
265 
266  mu_assert(q->tasks[0]->lambda == 1.000000,
267  "Incorrect lambda at task 0");
268  mu_assert(q->tasks[1]->lambda == 1.000000,
269  "Incorrect lambda at task 1");
270  mu_assert(q->tasks[2]->lambda == 1.000000,
271  "Incorrect lambda at task 2");
272  mu_assert(q->tasks[3]->lambda == 5.000000,
273  "Incorrect lambda at task 3");
274  mu_assert(q->tasks[4]->lambda == 5.000000,
275  "Incorrect lambda at task 4");
276  mu_assert(q->tasks[5]->lambda == 5.000000,
277  "Incorrect lambda at task 5");
278  mu_assert(q->tasks[6]->lambda == 1.000000,
279  "Incorrect lambda at task 6");
280  mu_assert(q->tasks[7]->lambda == 1.000000,
281  "Incorrect lambda at task 7");
282  mu_assert(q->tasks[8]->lambda == 1.000000,
283  "Incorrect lambda at task 8");
284  mu_assert(q->tasks[9]->lambda == 5.000000,
285  "Incorrect lambda at task 9");
286  mu_assert(q->tasks[10]->lambda == 5.000000,
287  "Incorrect lambda at task 10");
288  mu_assert(q->tasks[11]->lambda == 5.000000,
289  "Incorrect lambda at task 11");
290  mu_assert(q->tasks[12]->lambda == 1.000000,
291  "Incorrect lambda at task 12");
292  mu_assert(q->tasks[13]->lambda == 1.000000,
293  "Incorrect lambda at task 13");
294  mu_assert(q->tasks[14]->lambda == 1.000000,
295  "Incorrect lambda at task 14");
296  mu_assert(q->tasks[15]->lambda == 5.000000,
297  "Incorrect lambda at task 15");
298  mu_assert(q->tasks[16]->lambda == 5.000000,
299  "Incorrect lambda at task 16");
300  mu_assert(q->tasks[17]->lambda == 5.000000,
301  "Incorrect lambda at task 17");
302  mu_assert(q->tasks[18]->lambda == 1.000000,
303  "Incorrect lambda at task 18");
304  mu_assert(q->tasks[19]->lambda == 1.000000,
305  "Incorrect lambda at task 19");
306  mu_assert(q->tasks[20]->lambda == 1.000000,
307  "Incorrect lambda at task 20");
308  mu_assert(q->tasks[21]->lambda == 5.000000,
309  "Incorrect lambda at task 21");
310  mu_assert(q->tasks[22]->lambda == 5.000000,
311  "Incorrect lambda at task 22");
312  mu_assert(q->tasks[23]->lambda == 5.000000,
313  "Incorrect lambda at task 23");
314  mu_assert(q->tasks[24]->lambda == 1.000000,
315  "Incorrect lambda at task 24");
316  mu_assert(q->tasks[25]->lambda == 1.000000,
317  "Incorrect lambda at task 25");
318  mu_assert(q->tasks[26]->lambda == 1.000000,
319  "Incorrect lambda at task 26");
320  mu_assert(q->tasks[27]->lambda == 5.000000,
321  "Incorrect lambda at task 27");
322  mu_assert(q->tasks[28]->lambda == 5.000000,
323  "Incorrect lambda at task 28");
324  mu_assert(q->tasks[29]->lambda == 5.000000,
325  "Incorrect lambda at task 29");
326  mu_assert(q->tasks[30]->lambda == 1.000000,
327  "Incorrect lambda at task 30");
328  mu_assert(q->tasks[31]->lambda == 1.000000,
329  "Incorrect lambda at task 31");
330  mu_assert(q->tasks[32]->lambda == 1.000000,
331  "Incorrect lambda at task 32");
332  mu_assert(q->tasks[33]->lambda == 5.000000,
333  "Incorrect lambda at task 33");
334  mu_assert(q->tasks[34]->lambda == 5.000000,
335  "Incorrect lambda at task 34");
336  mu_assert(q->tasks[35]->lambda == 5.000000,
337  "Incorrect lambda at task 35");
338  mu_assert(q->tasks[36]->lambda == 1.000000,
339  "Incorrect lambda at task 36");
340  mu_assert(q->tasks[37]->lambda == 1.000000,
341  "Incorrect lambda at task 37");
342  mu_assert(q->tasks[38]->lambda == 1.000000,
343  "Incorrect lambda at task 38");
344  mu_assert(q->tasks[39]->lambda == 5.000000,
345  "Incorrect lambda at task 39");
346  mu_assert(q->tasks[40]->lambda == 5.000000,
347  "Incorrect lambda at task 40");
348  mu_assert(q->tasks[41]->lambda == 5.000000,
349  "Incorrect lambda at task 41");
350  mu_assert(q->tasks[42]->lambda == 1.000000,
351  "Incorrect lambda at task 42");
352  mu_assert(q->tasks[43]->lambda == 1.000000,
353  "Incorrect lambda at task 43");
354  mu_assert(q->tasks[44]->lambda == 1.000000,
355  "Incorrect lambda at task 44");
356  mu_assert(q->tasks[45]->lambda == 5.000000,
357  "Incorrect lambda at task 45");
358  mu_assert(q->tasks[46]->lambda == 5.000000,
359  "Incorrect lambda at task 46");
360  mu_assert(q->tasks[47]->lambda == 5.000000,
361  "Incorrect lambda at task 47");
362  mu_assert(q->tasks[48]->lambda == 1.000000,
363  "Incorrect lambda at task 48");
364  mu_assert(q->tasks[49]->lambda == 1.000000,
365  "Incorrect lambda at task 49");
366  mu_assert(q->tasks[50]->lambda == 1.000000,
367  "Incorrect lambda at task 50");
368  mu_assert(q->tasks[51]->lambda == 5.000000,
369  "Incorrect lambda at task 51");
370  mu_assert(q->tasks[52]->lambda == 5.000000,
371  "Incorrect lambda at task 52");
372  mu_assert(q->tasks[53]->lambda == 5.000000,
373  "Incorrect lambda at task 53");
374  mu_assert(q->tasks[54]->lambda == 1.000000,
375  "Incorrect lambda at task 54");
376  mu_assert(q->tasks[55]->lambda == 1.000000,
377  "Incorrect lambda at task 55");
378  mu_assert(q->tasks[56]->lambda == 1.000000,
379  "Incorrect lambda at task 56");
380  mu_assert(q->tasks[57]->lambda == 5.000000,
381  "Incorrect lambda at task 57");
382  mu_assert(q->tasks[58]->lambda == 5.000000,
383  "Incorrect lambda at task 58");
384  mu_assert(q->tasks[59]->lambda == 5.000000,
385  "Incorrect lambda at task 59");
386  mu_assert(q->tasks[60]->lambda == 1.000000,
387  "Incorrect lambda at task 60");
388  mu_assert(q->tasks[61]->lambda == 1.000000,
389  "Incorrect lambda at task 61");
390  mu_assert(q->tasks[62]->lambda == 1.000000,
391  "Incorrect lambda at task 62");
392  mu_assert(q->tasks[63]->lambda == 5.000000,
393  "Incorrect lambda at task 63");
394  mu_assert(q->tasks[64]->lambda == 5.000000,
395  "Incorrect lambda at task 64");
396  mu_assert(q->tasks[65]->lambda == 5.000000,
397  "Incorrect lambda at task 65");
398  mu_assert(q->tasks[66]->lambda == 1.000000,
399  "Incorrect lambda at task 66");
400  mu_assert(q->tasks[67]->lambda == 1.000000,
401  "Incorrect lambda at task 67");
402  mu_assert(q->tasks[68]->lambda == 1.000000,
403  "Incorrect lambda at task 68");
404  mu_assert(q->tasks[69]->lambda == 5.000000,
405  "Incorrect lambda at task 69");
406  mu_assert(q->tasks[70]->lambda == 5.000000,
407  "Incorrect lambda at task 70");
408  mu_assert(q->tasks[71]->lambda == 5.000000,
409  "Incorrect lambda at task 71");
410 
411  mu_assert(q->tasks[0]->gamma == 0.500000,
412  "Incorrect gamma at task 0");
413  mu_assert(q->tasks[1]->gamma == 0.500000,
414  "Incorrect gamma at task 1");
415  mu_assert(q->tasks[2]->gamma == 0.500000,
416  "Incorrect gamma at task 2");
417  mu_assert(q->tasks[3]->gamma == 0.500000,
418  "Incorrect gamma at task 3");
419  mu_assert(q->tasks[4]->gamma == 0.500000,
420  "Incorrect gamma at task 4");
421  mu_assert(q->tasks[5]->gamma == 0.500000,
422  "Incorrect gamma at task 5");
423  mu_assert(q->tasks[6]->gamma == 1.500000,
424  "Incorrect gamma at task 6");
425  mu_assert(q->tasks[7]->gamma == 1.500000,
426  "Incorrect gamma at task 7");
427  mu_assert(q->tasks[8]->gamma == 1.500000,
428  "Incorrect gamma at task 8");
429  mu_assert(q->tasks[9]->gamma == 1.500000,
430  "Incorrect gamma at task 9");
431  mu_assert(q->tasks[10]->gamma == 1.500000,
432  "Incorrect gamma at task 10");
433  mu_assert(q->tasks[11]->gamma == 1.500000,
434  "Incorrect gamma at task 11");
435  mu_assert(q->tasks[12]->gamma == 0.500000,
436  "Incorrect gamma at task 12");
437  mu_assert(q->tasks[13]->gamma == 0.500000,
438  "Incorrect gamma at task 13");
439  mu_assert(q->tasks[14]->gamma == 0.500000,
440  "Incorrect gamma at task 14");
441  mu_assert(q->tasks[15]->gamma == 0.500000,
442  "Incorrect gamma at task 15");
443  mu_assert(q->tasks[16]->gamma == 0.500000,
444  "Incorrect gamma at task 16");
445  mu_assert(q->tasks[17]->gamma == 0.500000,
446  "Incorrect gamma at task 17");
447  mu_assert(q->tasks[18]->gamma == 1.500000,
448  "Incorrect gamma at task 18");
449  mu_assert(q->tasks[19]->gamma == 1.500000,
450  "Incorrect gamma at task 19");
451  mu_assert(q->tasks[20]->gamma == 1.500000,
452  "Incorrect gamma at task 20");
453  mu_assert(q->tasks[21]->gamma == 1.500000,
454  "Incorrect gamma at task 21");
455  mu_assert(q->tasks[22]->gamma == 1.500000,
456  "Incorrect gamma at task 22");
457  mu_assert(q->tasks[23]->gamma == 1.500000,
458  "Incorrect gamma at task 23");
459  mu_assert(q->tasks[24]->gamma == 0.500000,
460  "Incorrect gamma at task 24");
461  mu_assert(q->tasks[25]->gamma == 0.500000,
462  "Incorrect gamma at task 25");
463  mu_assert(q->tasks[26]->gamma == 0.500000,
464  "Incorrect gamma at task 26");
465  mu_assert(q->tasks[27]->gamma == 0.500000,
466  "Incorrect gamma at task 27");
467  mu_assert(q->tasks[28]->gamma == 0.500000,
468  "Incorrect gamma at task 28");
469  mu_assert(q->tasks[29]->gamma == 0.500000,
470  "Incorrect gamma at task 29");
471  mu_assert(q->tasks[30]->gamma == 1.500000,
472  "Incorrect gamma at task 30");
473  mu_assert(q->tasks[31]->gamma == 1.500000,
474  "Incorrect gamma at task 31");
475  mu_assert(q->tasks[32]->gamma == 1.500000,
476  "Incorrect gamma at task 32");
477  mu_assert(q->tasks[33]->gamma == 1.500000,
478  "Incorrect gamma at task 33");
479  mu_assert(q->tasks[34]->gamma == 1.500000,
480  "Incorrect gamma at task 34");
481  mu_assert(q->tasks[35]->gamma == 1.500000,
482  "Incorrect gamma at task 35");
483  mu_assert(q->tasks[36]->gamma == 0.500000,
484  "Incorrect gamma at task 36");
485  mu_assert(q->tasks[37]->gamma == 0.500000,
486  "Incorrect gamma at task 37");
487  mu_assert(q->tasks[38]->gamma == 0.500000,
488  "Incorrect gamma at task 38");
489  mu_assert(q->tasks[39]->gamma == 0.500000,
490  "Incorrect gamma at task 39");
491  mu_assert(q->tasks[40]->gamma == 0.500000,
492  "Incorrect gamma at task 40");
493  mu_assert(q->tasks[41]->gamma == 0.500000,
494  "Incorrect gamma at task 41");
495  mu_assert(q->tasks[42]->gamma == 1.500000,
496  "Incorrect gamma at task 42");
497  mu_assert(q->tasks[43]->gamma == 1.500000,
498  "Incorrect gamma at task 43");
499  mu_assert(q->tasks[44]->gamma == 1.500000,
500  "Incorrect gamma at task 44");
501  mu_assert(q->tasks[45]->gamma == 1.500000,
502  "Incorrect gamma at task 45");
503  mu_assert(q->tasks[46]->gamma == 1.500000,
504  "Incorrect gamma at task 46");
505  mu_assert(q->tasks[47]->gamma == 1.500000,
506  "Incorrect gamma at task 47");
507  mu_assert(q->tasks[48]->gamma == 0.500000,
508  "Incorrect gamma at task 48");
509  mu_assert(q->tasks[49]->gamma == 0.500000,
510  "Incorrect gamma at task 49");
511  mu_assert(q->tasks[50]->gamma == 0.500000,
512  "Incorrect gamma at task 50");
513  mu_assert(q->tasks[51]->gamma == 0.500000,
514  "Incorrect gamma at task 51");
515  mu_assert(q->tasks[52]->gamma == 0.500000,
516  "Incorrect gamma at task 52");
517  mu_assert(q->tasks[53]->gamma == 0.500000,
518  "Incorrect gamma at task 53");
519  mu_assert(q->tasks[54]->gamma == 1.500000,
520  "Incorrect gamma at task 54");
521  mu_assert(q->tasks[55]->gamma == 1.500000,
522  "Incorrect gamma at task 55");
523  mu_assert(q->tasks[56]->gamma == 1.500000,
524  "Incorrect gamma at task 56");
525  mu_assert(q->tasks[57]->gamma == 1.500000,
526  "Incorrect gamma at task 57");
527  mu_assert(q->tasks[58]->gamma == 1.500000,
528  "Incorrect gamma at task 58");
529  mu_assert(q->tasks[59]->gamma == 1.500000,
530  "Incorrect gamma at task 59");
531  mu_assert(q->tasks[60]->gamma == 0.500000,
532  "Incorrect gamma at task 60");
533  mu_assert(q->tasks[61]->gamma == 0.500000,
534  "Incorrect gamma at task 61");
535  mu_assert(q->tasks[62]->gamma == 0.500000,
536  "Incorrect gamma at task 62");
537  mu_assert(q->tasks[63]->gamma == 0.500000,
538  "Incorrect gamma at task 63");
539  mu_assert(q->tasks[64]->gamma == 0.500000,
540  "Incorrect gamma at task 64");
541  mu_assert(q->tasks[65]->gamma == 0.500000,
542  "Incorrect gamma at task 65");
543  mu_assert(q->tasks[66]->gamma == 1.500000,
544  "Incorrect gamma at task 66");
545  mu_assert(q->tasks[67]->gamma == 1.500000,
546  "Incorrect gamma at task 67");
547  mu_assert(q->tasks[68]->gamma == 1.500000,
548  "Incorrect gamma at task 68");
549  mu_assert(q->tasks[69]->gamma == 1.500000,
550  "Incorrect gamma at task 69");
551  mu_assert(q->tasks[70]->gamma == 1.500000,
552  "Incorrect gamma at task 70");
553  mu_assert(q->tasks[71]->gamma == 1.500000,
554  "Incorrect gamma at task 71");
555 
556  mu_assert(q->tasks[0]->coef == 7.000000,
557  "Incorrect coef at task 0");
558  mu_assert(q->tasks[1]->coef == 7.000000,
559  "Incorrect coef at task 1");
560  mu_assert(q->tasks[2]->coef == 7.000000,
561  "Incorrect coef at task 2");
562  mu_assert(q->tasks[3]->coef == 7.000000,
563  "Incorrect coef at task 3");
564  mu_assert(q->tasks[4]->coef == 7.000000,
565  "Incorrect coef at task 4");
566  mu_assert(q->tasks[5]->coef == 7.000000,
567  "Incorrect coef at task 5");
568  mu_assert(q->tasks[6]->coef == 7.000000,
569  "Incorrect coef at task 6");
570  mu_assert(q->tasks[7]->coef == 7.000000,
571  "Incorrect coef at task 7");
572  mu_assert(q->tasks[8]->coef == 7.000000,
573  "Incorrect coef at task 8");
574  mu_assert(q->tasks[9]->coef == 7.000000,
575  "Incorrect coef at task 9");
576  mu_assert(q->tasks[10]->coef == 7.000000,
577  "Incorrect coef at task 10");
578  mu_assert(q->tasks[11]->coef == 7.000000,
579  "Incorrect coef at task 11");
580  mu_assert(q->tasks[12]->coef == 11.000000,
581  "Incorrect coef at task 12");
582  mu_assert(q->tasks[13]->coef == 11.000000,
583  "Incorrect coef at task 13");
584  mu_assert(q->tasks[14]->coef == 11.000000,
585  "Incorrect coef at task 14");
586  mu_assert(q->tasks[15]->coef == 11.000000,
587  "Incorrect coef at task 15");
588  mu_assert(q->tasks[16]->coef == 11.000000,
589  "Incorrect coef at task 16");
590  mu_assert(q->tasks[17]->coef == 11.000000,
591  "Incorrect coef at task 17");
592  mu_assert(q->tasks[18]->coef == 11.000000,
593  "Incorrect coef at task 18");
594  mu_assert(q->tasks[19]->coef == 11.000000,
595  "Incorrect coef at task 19");
596  mu_assert(q->tasks[20]->coef == 11.000000,
597  "Incorrect coef at task 20");
598  mu_assert(q->tasks[21]->coef == 11.000000,
599  "Incorrect coef at task 21");
600  mu_assert(q->tasks[22]->coef == 11.000000,
601  "Incorrect coef at task 22");
602  mu_assert(q->tasks[23]->coef == 11.000000,
603  "Incorrect coef at task 23");
604  mu_assert(q->tasks[24]->coef == 13.000000,
605  "Incorrect coef at task 24");
606  mu_assert(q->tasks[25]->coef == 13.000000,
607  "Incorrect coef at task 25");
608  mu_assert(q->tasks[26]->coef == 13.000000,
609  "Incorrect coef at task 26");
610  mu_assert(q->tasks[27]->coef == 13.000000,
611  "Incorrect coef at task 27");
612  mu_assert(q->tasks[28]->coef == 13.000000,
613  "Incorrect coef at task 28");
614  mu_assert(q->tasks[29]->coef == 13.000000,
615  "Incorrect coef at task 29");
616  mu_assert(q->tasks[30]->coef == 13.000000,
617  "Incorrect coef at task 30");
618  mu_assert(q->tasks[31]->coef == 13.000000,
619  "Incorrect coef at task 31");
620  mu_assert(q->tasks[32]->coef == 13.000000,
621  "Incorrect coef at task 32");
622  mu_assert(q->tasks[33]->coef == 13.000000,
623  "Incorrect coef at task 33");
624  mu_assert(q->tasks[34]->coef == 13.000000,
625  "Incorrect coef at task 34");
626  mu_assert(q->tasks[35]->coef == 13.000000,
627  "Incorrect coef at task 35");
628  mu_assert(q->tasks[36]->coef == 7.000000,
629  "Incorrect coef at task 36");
630  mu_assert(q->tasks[37]->coef == 7.000000,
631  "Incorrect coef at task 37");
632  mu_assert(q->tasks[38]->coef == 7.000000,
633  "Incorrect coef at task 38");
634  mu_assert(q->tasks[39]->coef == 7.000000,
635  "Incorrect coef at task 39");
636  mu_assert(q->tasks[40]->coef == 7.000000,
637  "Incorrect coef at task 40");
638  mu_assert(q->tasks[41]->coef == 7.000000,
639  "Incorrect coef at task 41");
640  mu_assert(q->tasks[42]->coef == 7.000000,
641  "Incorrect coef at task 42");
642  mu_assert(q->tasks[43]->coef == 7.000000,
643  "Incorrect coef at task 43");
644  mu_assert(q->tasks[44]->coef == 7.000000,
645  "Incorrect coef at task 44");
646  mu_assert(q->tasks[45]->coef == 7.000000,
647  "Incorrect coef at task 45");
648  mu_assert(q->tasks[46]->coef == 7.000000,
649  "Incorrect coef at task 46");
650  mu_assert(q->tasks[47]->coef == 7.000000,
651  "Incorrect coef at task 47");
652  mu_assert(q->tasks[48]->coef == 11.000000,
653  "Incorrect coef at task 48");
654  mu_assert(q->tasks[49]->coef == 11.000000,
655  "Incorrect coef at task 49");
656  mu_assert(q->tasks[50]->coef == 11.000000,
657  "Incorrect coef at task 50");
658  mu_assert(q->tasks[51]->coef == 11.000000,
659  "Incorrect coef at task 51");
660  mu_assert(q->tasks[52]->coef == 11.000000,
661  "Incorrect coef at task 52");
662  mu_assert(q->tasks[53]->coef == 11.000000,
663  "Incorrect coef at task 53");
664  mu_assert(q->tasks[54]->coef == 11.000000,
665  "Incorrect coef at task 54");
666  mu_assert(q->tasks[55]->coef == 11.000000,
667  "Incorrect coef at task 55");
668  mu_assert(q->tasks[56]->coef == 11.000000,
669  "Incorrect coef at task 56");
670  mu_assert(q->tasks[57]->coef == 11.000000,
671  "Incorrect coef at task 57");
672  mu_assert(q->tasks[58]->coef == 11.000000,
673  "Incorrect coef at task 58");
674  mu_assert(q->tasks[59]->coef == 11.000000,
675  "Incorrect coef at task 59");
676  mu_assert(q->tasks[60]->coef == 13.000000,
677  "Incorrect coef at task 60");
678  mu_assert(q->tasks[61]->coef == 13.000000,
679  "Incorrect coef at task 61");
680  mu_assert(q->tasks[62]->coef == 13.000000,
681  "Incorrect coef at task 62");
682  mu_assert(q->tasks[63]->coef == 13.000000,
683  "Incorrect coef at task 63");
684  mu_assert(q->tasks[64]->coef == 13.000000,
685  "Incorrect coef at task 64");
686  mu_assert(q->tasks[65]->coef == 13.000000,
687  "Incorrect coef at task 65");
688  mu_assert(q->tasks[66]->coef == 13.000000,
689  "Incorrect coef at task 66");
690  mu_assert(q->tasks[67]->coef == 13.000000,
691  "Incorrect coef at task 67");
692  mu_assert(q->tasks[68]->coef == 13.000000,
693  "Incorrect coef at task 68");
694  mu_assert(q->tasks[69]->coef == 13.000000,
695  "Incorrect coef at task 69");
696  mu_assert(q->tasks[70]->coef == 13.000000,
697  "Incorrect coef at task 70");
698  mu_assert(q->tasks[71]->coef == 13.000000,
699  "Incorrect coef at task 71");
700 
701  mu_assert(q->tasks[0]->degree == 3.000000,
702  "Incorrect degree at task 0");
703  mu_assert(q->tasks[1]->degree == 3.000000,
704  "Incorrect degree at task 1");
705  mu_assert(q->tasks[2]->degree == 3.000000,
706  "Incorrect degree at task 2");
707  mu_assert(q->tasks[3]->degree == 3.000000,
708  "Incorrect degree at task 3");
709  mu_assert(q->tasks[4]->degree == 3.000000,
710  "Incorrect degree at task 4");
711  mu_assert(q->tasks[5]->degree == 3.000000,
712  "Incorrect degree at task 5");
713  mu_assert(q->tasks[6]->degree == 3.000000,
714  "Incorrect degree at task 6");
715  mu_assert(q->tasks[7]->degree == 3.000000,
716  "Incorrect degree at task 7");
717  mu_assert(q->tasks[8]->degree == 3.000000,
718  "Incorrect degree at task 8");
719  mu_assert(q->tasks[9]->degree == 3.000000,
720  "Incorrect degree at task 9");
721  mu_assert(q->tasks[10]->degree == 3.000000,
722  "Incorrect degree at task 10");
723  mu_assert(q->tasks[11]->degree == 3.000000,
724  "Incorrect degree at task 11");
725  mu_assert(q->tasks[12]->degree == 3.000000,
726  "Incorrect degree at task 12");
727  mu_assert(q->tasks[13]->degree == 3.000000,
728  "Incorrect degree at task 13");
729  mu_assert(q->tasks[14]->degree == 3.000000,
730  "Incorrect degree at task 14");
731  mu_assert(q->tasks[15]->degree == 3.000000,
732  "Incorrect degree at task 15");
733  mu_assert(q->tasks[16]->degree == 3.000000,
734  "Incorrect degree at task 16");
735  mu_assert(q->tasks[17]->degree == 3.000000,
736  "Incorrect degree at task 17");
737  mu_assert(q->tasks[18]->degree == 3.000000,
738  "Incorrect degree at task 18");
739  mu_assert(q->tasks[19]->degree == 3.000000,
740  "Incorrect degree at task 19");
741  mu_assert(q->tasks[20]->degree == 3.000000,
742  "Incorrect degree at task 20");
743  mu_assert(q->tasks[21]->degree == 3.000000,
744  "Incorrect degree at task 21");
745  mu_assert(q->tasks[22]->degree == 3.000000,
746  "Incorrect degree at task 22");
747  mu_assert(q->tasks[23]->degree == 3.000000,
748  "Incorrect degree at task 23");
749  mu_assert(q->tasks[24]->degree == 3.000000,
750  "Incorrect degree at task 24");
751  mu_assert(q->tasks[25]->degree == 3.000000,
752  "Incorrect degree at task 25");
753  mu_assert(q->tasks[26]->degree == 3.000000,
754  "Incorrect degree at task 26");
755  mu_assert(q->tasks[27]->degree == 3.000000,
756  "Incorrect degree at task 27");
757  mu_assert(q->tasks[28]->degree == 3.000000,
758  "Incorrect degree at task 28");
759  mu_assert(q->tasks[29]->degree == 3.000000,
760  "Incorrect degree at task 29");
761  mu_assert(q->tasks[30]->degree == 3.000000,
762  "Incorrect degree at task 30");
763  mu_assert(q->tasks[31]->degree == 3.000000,
764  "Incorrect degree at task 31");
765  mu_assert(q->tasks[32]->degree == 3.000000,
766  "Incorrect degree at task 32");
767  mu_assert(q->tasks[33]->degree == 3.000000,
768  "Incorrect degree at task 33");
769  mu_assert(q->tasks[34]->degree == 3.000000,
770  "Incorrect degree at task 34");
771  mu_assert(q->tasks[35]->degree == 3.000000,
772  "Incorrect degree at task 35");
773  mu_assert(q->tasks[36]->degree == 5.000000,
774  "Incorrect degree at task 36");
775  mu_assert(q->tasks[37]->degree == 5.000000,
776  "Incorrect degree at task 37");
777  mu_assert(q->tasks[38]->degree == 5.000000,
778  "Incorrect degree at task 38");
779  mu_assert(q->tasks[39]->degree == 5.000000,
780  "Incorrect degree at task 39");
781  mu_assert(q->tasks[40]->degree == 5.000000,
782  "Incorrect degree at task 40");
783  mu_assert(q->tasks[41]->degree == 5.000000,
784  "Incorrect degree at task 41");
785  mu_assert(q->tasks[42]->degree == 5.000000,
786  "Incorrect degree at task 42");
787  mu_assert(q->tasks[43]->degree == 5.000000,
788  "Incorrect degree at task 43");
789  mu_assert(q->tasks[44]->degree == 5.000000,
790  "Incorrect degree at task 44");
791  mu_assert(q->tasks[45]->degree == 5.000000,
792  "Incorrect degree at task 45");
793  mu_assert(q->tasks[46]->degree == 5.000000,
794  "Incorrect degree at task 46");
795  mu_assert(q->tasks[47]->degree == 5.000000,
796  "Incorrect degree at task 47");
797  mu_assert(q->tasks[48]->degree == 5.000000,
798  "Incorrect degree at task 48");
799  mu_assert(q->tasks[49]->degree == 5.000000,
800  "Incorrect degree at task 49");
801  mu_assert(q->tasks[50]->degree == 5.000000,
802  "Incorrect degree at task 50");
803  mu_assert(q->tasks[51]->degree == 5.000000,
804  "Incorrect degree at task 51");
805  mu_assert(q->tasks[52]->degree == 5.000000,
806  "Incorrect degree at task 52");
807  mu_assert(q->tasks[53]->degree == 5.000000,
808  "Incorrect degree at task 53");
809  mu_assert(q->tasks[54]->degree == 5.000000,
810  "Incorrect degree at task 54");
811  mu_assert(q->tasks[55]->degree == 5.000000,
812  "Incorrect degree at task 55");
813  mu_assert(q->tasks[56]->degree == 5.000000,
814  "Incorrect degree at task 56");
815  mu_assert(q->tasks[57]->degree == 5.000000,
816  "Incorrect degree at task 57");
817  mu_assert(q->tasks[58]->degree == 5.000000,
818  "Incorrect degree at task 58");
819  mu_assert(q->tasks[59]->degree == 5.000000,
820  "Incorrect degree at task 59");
821  mu_assert(q->tasks[60]->degree == 5.000000,
822  "Incorrect degree at task 60");
823  mu_assert(q->tasks[61]->degree == 5.000000,
824  "Incorrect degree at task 61");
825  mu_assert(q->tasks[62]->degree == 5.000000,
826  "Incorrect degree at task 62");
827  mu_assert(q->tasks[63]->degree == 5.000000,
828  "Incorrect degree at task 63");
829  mu_assert(q->tasks[64]->degree == 5.000000,
830  "Incorrect degree at task 64");
831  mu_assert(q->tasks[65]->degree == 5.000000,
832  "Incorrect degree at task 65");
833  mu_assert(q->tasks[66]->degree == 5.000000,
834  "Incorrect degree at task 66");
835  mu_assert(q->tasks[67]->degree == 5.000000,
836  "Incorrect degree at task 67");
837  mu_assert(q->tasks[68]->degree == 5.000000,
838  "Incorrect degree at task 68");
839  mu_assert(q->tasks[69]->degree == 5.000000,
840  "Incorrect degree at task 69");
841  mu_assert(q->tasks[70]->degree == 5.000000,
842  "Incorrect degree at task 70");
843  mu_assert(q->tasks[71]->degree == 5.000000,
844  "Incorrect degree at task 71");
845  gensvm_free_queue(q);
846  // end test code //
847 
848  gensvm_free_data(train_data);
849  gensvm_free_data(test_data);
850  gensvm_free_grid(grid);
851 
852  return NULL;
853 }
854 
855 
856 char *test_kernel_changed()
857 {
858  struct GenTask *new = gensvm_init_task();
859  struct GenTask *old = gensvm_init_task();
860 
861  // start test code //
862  mu_assert(gensvm_kernel_changed(new, NULL) == true,
863  "Incorrect kernel changed (1)");
864 
865  mu_assert(gensvm_kernel_changed(new, old) == false,
866  "Incorrect kernel changed (2)");
867 
868  new->kerneltype = K_RBF;
869  mu_assert(gensvm_kernel_changed(new, old) == true,
870  "Incorrect kernel changed (3)");
871 
872  // rbf kernel
873  old->kerneltype = K_RBF;
874  old->gamma = 1.0;
875  new->gamma = 1.0;
876  mu_assert(gensvm_kernel_changed(new, old) == false,
877  "Incorrect kernel changed (4)");
878  new->gamma = 2.0;
879  mu_assert(gensvm_kernel_changed(new, old) == true,
880  "Incorrect kernel changed (5)");
881 
882  // poly kernel
883  old->kerneltype = K_POLY;
884  new->kerneltype = K_POLY;
885  old->gamma = 1.0;
886  old->coef = 2.0;
887  old->degree = 3.0;
888 
889  new->gamma = 1.0;
890  new->coef = 2.0;
891  new->degree = 3.0;
892  mu_assert(gensvm_kernel_changed(new, old) == false,
893  "Incorrect kernel changed (6)");
894  new->degree = 5.0;
895  mu_assert(gensvm_kernel_changed(new, old) == true,
896  "Incorrect kernel changed (7)");
897 
898  // sigmoid kernel
899  old->kerneltype = K_SIGMOID;
900  new->kerneltype = K_SIGMOID;
901  old->gamma = 1.0;
902  old->coef = 2.0;
903  new->gamma = 1.0;
904  new->coef = 2.0;
905 
906  mu_assert(gensvm_kernel_changed(new, old) == false,
907  "Incorrect kernel changed (8)");
908  new->coef = 5.0;
909  mu_assert(gensvm_kernel_changed(new, old) == true,
910  "Incorrect kernel changed (9)");
911 
912  // end test code //
913  gensvm_free_task(new);
914  gensvm_free_task(old);
915 
916  return NULL;
917 }
918 
919 char *test_kernel_folds()
920 {
921  mu_test_missing();
922 
923  return NULL;
924 }
925 
926 char *test_train_queue()
927 {
928  mu_test_missing();
929 
930  return NULL;
931 }
932 
933 char *test_gridsearch_progress_linear()
934 {
935  FILE *fid = NULL;
936  const char *filename = "./data/test_progress_string.txt";
937  GENSVM_OUTPUT_FILE = fopen(filename, "w");
938 
939  struct GenTask *task = gensvm_init_task();
940  task->ID = 0;
941 
942  // start test code //
943  gensvm_gridsearch_progress(task, 10, 0.5, 0.123, 0.7);
944  fclose(GENSVM_OUTPUT_FILE);
945 
946  char buffer[GENSVM_MAX_LINE_LENGTH];
947  fid = fopen(filename, "r");
948 
949  fgets(buffer, GENSVM_MAX_LINE_LENGTH, fid);
950  const char *expected = ("(001/010)\teps = 1e-06\tw = 1\tk = 0.00\t"
951  "l = 1.000000\tp = 1.00\t\t0.500% (0.123s)\t"
952  "(best = 0.700%)\n");
953  mu_assert(strcmp(buffer, expected) == 0, "Incorrect progress string");
954 
955  fclose(fid);
956  // end test code //
957  gensvm_free_task(task);
958 
959  return NULL;
960 }
961 
962 char *test_gridsearch_progress_rbf()
963 {
964  FILE *fid = NULL;
965  const char *filename = "./data/test_progress_string.txt";
966  GENSVM_OUTPUT_FILE = fopen(filename, "w");
967 
968  struct GenTask *task = gensvm_init_task();
969  task->ID = 0;
970  task->kerneltype = K_RBF;
971  task->gamma = 3.0;
972 
973  // start test code //
974  gensvm_gridsearch_progress(task, 10, 0.5, 0.123, 0.7);
975  fclose(GENSVM_OUTPUT_FILE);
976 
977  char buffer[GENSVM_MAX_LINE_LENGTH];
978  fid = fopen(filename, "r");
979 
980  fgets(buffer, GENSVM_MAX_LINE_LENGTH, fid);
981  const char *expected = ("(001/010)\tg = 3.000\teps = 1e-06\tw = 1\t"
982  "k = 0.00\tl = 1.000000\tp = 1.00\t\t0.500% (0.123s)\t"
983  "(best = 0.700%)\n");
984  mu_assert(strcmp(buffer, expected) == 0, "Incorrect progress string");
985 
986  fclose(fid);
987  // end test code //
988  gensvm_free_task(task);
989 
990  return NULL;
991 }
992 
993 char *test_gridsearch_progress_poly()
994 {
995  FILE *fid = NULL;
996  const char *filename = "./data/test_progress_string.txt";
997  GENSVM_OUTPUT_FILE = fopen(filename, "w");
998 
999  struct GenTask *task = gensvm_init_task();
1000  task->ID = 0;
1001  task->kerneltype = K_POLY;
1002  task->gamma = 3.0;
1003  task->coef = 1.0;
1004  task->degree = 2.0;
1005 
1006  // start test code //
1007  gensvm_gridsearch_progress(task, 10, 0.5, 0.123, 0.7);
1008  fclose(GENSVM_OUTPUT_FILE);
1009 
1010  char buffer[GENSVM_MAX_LINE_LENGTH];
1011  fid = fopen(filename, "r");
1012 
1013  fgets(buffer, GENSVM_MAX_LINE_LENGTH, fid);
1014  const char *expected = ("(001/010)\t"
1015  "d = 2.00\tc = 1.00\tg = 3.000\t"
1016  "eps = 1e-06\tw = 1\tk = 0.00\t"
1017  "l = 1.000000\tp = 1.00\t\t0.500% (0.123s)\t"
1018  "(best = 0.700%)\n");
1019  mu_assert(strcmp(buffer, expected) == 0, "Incorrect progress string");
1020 
1021  fclose(fid);
1022  // end test code //
1023  gensvm_free_task(task);
1024 
1025  return NULL;
1026 }
1027 
1028 char *test_gridsearch_progress_sigmoid()
1029 {
1030  FILE *fid = NULL;
1031  const char *filename = "./data/test_progress_string.txt";
1032  GENSVM_OUTPUT_FILE = fopen(filename, "w");
1033 
1034  struct GenTask *task = gensvm_init_task();
1035  task->ID = 0;
1036  task->kerneltype = K_SIGMOID;
1037  task->gamma = 3.0;
1038  task->coef = 1.0;
1039 
1040  // start test code //
1041  gensvm_gridsearch_progress(task, 10, 0.5, 0.123, 0.7);
1042  fclose(GENSVM_OUTPUT_FILE);
1043 
1044  char buffer[GENSVM_MAX_LINE_LENGTH];
1045  fid = fopen(filename, "r");
1046 
1047  fgets(buffer, GENSVM_MAX_LINE_LENGTH, fid);
1048  const char *expected = ("(001/010)\t"
1049  "c = 1.00\tg = 3.000\t"
1050  "eps = 1e-06\tw = 1\tk = 0.00\t"
1051  "l = 1.000000\tp = 1.00\t\t0.500% (0.123s)\t"
1052  "(best = 0.700%)\n");
1053  mu_assert(strcmp(buffer, expected) == 0, "Incorrect progress string");
1054 
1055  fclose(fid);
1056  // end test code //
1057  gensvm_free_task(task);
1058 
1059  return NULL;
1060 }
1061 
1062 char *all_tests()
1063 {
1064  mu_suite_start();
1065  mu_run_test(test_fill_queue_nokernel);
1066  mu_run_test(test_fill_queue_kernel);
1067  mu_run_test(test_kernel_changed);
1068  mu_run_test(test_kernel_folds);
1069  mu_run_test(test_train_queue);
1070  mu_run_test(test_gridsearch_progress_linear);
1071  mu_run_test(test_gridsearch_progress_rbf);
1072  mu_run_test(test_gridsearch_progress_poly);
1073  mu_run_test(test_gridsearch_progress_sigmoid);
1074 
1075  return NULL;
1076 }
1077 
1078 RUN_TESTS(all_tests);
minunit.h
Minimal unit testing framework for C.
Calloc
#define Calloc(type, size)
Definition: gensvm_memory.h:40
GenTask::folds
long folds
number of folds in cross validation
Definition: gensvm_task.h:60
GenGrid
Structure for describing the entire grid search.
Definition: gensvm_grid.h:67
K_LINEAR
Definition: gensvm_globals.h:68
GenGrid::epsilons
double * epsilons
array of epsilon values
Definition: gensvm_grid.h:103
gensvm_init_queue
struct GenQueue * gensvm_init_queue(void)
Initialize a GenQueue structure.
Definition: gensvm_queue.c:38
GenTask::coef
double coef
coef parameter for the GenModel
Definition: gensvm_task.h:74
test_fill_queue_nokernel
char * test_fill_queue_nokernel()
Definition: test_gensvm_gridsearch.c:32
GenTask::ID
long ID
numeric id of the task in the queue
Definition: gensvm_task.h:62
gensvm_gridsearch_progress
void gensvm_gridsearch_progress(struct GenTask *task, long N, double perf, double duration, double current_max)
Print the description of the current task on screen.
Definition: gensvm_gridsearch.c:357
test_kernel_folds
char * test_kernel_folds()
Definition: test_gensvm_gridsearch.c:919
mu_assert
#define mu_assert(test, message)
Definition: minunit.h:29
GENSVM_MAX_LINE_LENGTH
#define GENSVM_MAX_LINE_LENGTH
Definition: gensvm_globals.h:80
GenGrid::Np
long Np
size of the array of p values
Definition: gensvm_grid.h:79
GenGrid::Ne
long Ne
size of the array of epsilon values
Definition: gensvm_grid.h:85
GenGrid::Nc
long Nc
size of the array of coef values
Definition: gensvm_grid.h:91
GenGrid::degrees
double * degrees
array of degree values
Definition: gensvm_grid.h:109
GenGrid::Nk
long Nk
size of the array of kappa values
Definition: gensvm_grid.h:83
GenGrid::Nw
long Nw
size of the array of weight_idx values
Definition: gensvm_grid.h:87
GenGrid::kerneltype
KernelType kerneltype
type of kernel to use throughout training
Definition: gensvm_grid.h:70
gensvm_init_task
struct GenTask * gensvm_init_task(void)
Initialize a GenTask structure.
Definition: gensvm_task.c:38
GenQueue::N
long N
size of task array
Definition: gensvm_queue.h:50
GenQueue::i
long i
index used for keeping track of the queue
Definition: gensvm_queue.h:52
test_gridsearch_progress_rbf
char * test_gridsearch_progress_rbf()
Definition: test_gensvm_gridsearch.c:962
gensvm_fill_queue
void gensvm_fill_queue(struct GenGrid *grid, struct GenQueue *queue, struct GenData *train_data, struct GenData *test_data)
Initialize a GenQueue from a Training instance.
Definition: gensvm_gridsearch.c:54
mu_run_test
#define mu_run_test(test)
Definition: minunit.h:35
test_gridsearch_progress_poly
char * test_gridsearch_progress_poly()
Definition: test_gensvm_gridsearch.c:993
GenTask::gamma
double gamma
gamma parameter for the GenModel
Definition: gensvm_task.h:72
GenGrid::lambdas
double * lambdas
array of lambda values
Definition: gensvm_grid.h:99
GenQueue
Simple task queue.
Definition: gensvm_queue.h:47
GenTask::kerneltype
KernelType kerneltype
kerneltype parameter for the GenModel
Definition: gensvm_task.h:56
GenData
A structure to represent the data.
Definition: gensvm_base.h:57
GenTask::test_data
struct GenData * test_data
pointer to the test data (if any)
Definition: gensvm_task.h:82
test_gridsearch_progress_sigmoid
char * test_gridsearch_progress_sigmoid()
Definition: test_gensvm_gridsearch.c:1028
K_RBF
Definition: gensvm_globals.h:70
mu_test_missing
#define mu_test_missing()
Definition: minunit.h:60
gensvm_gridsearch.h
Header file for gensvm_gridsearch.c.
K_POLY
Definition: gensvm_globals.h:69
GenTask::degree
double degree
degree parameter for the GenModel
Definition: gensvm_task.h:76
all_tests
char * all_tests()
Definition: test_gensvm_gridsearch.c:1062
test_train_queue
char * test_train_queue()
Definition: test_gensvm_gridsearch.c:926
test_kernel_changed
char * test_kernel_changed()
Definition: test_gensvm_gridsearch.c:856
GenGrid::Nl
long Nl
size of the array of lambda values
Definition: gensvm_grid.h:81
GenGrid::kappas
double * kappas
array of kappa values
Definition: gensvm_grid.h:101
GenGrid::Ng
long Ng
size of the array of gamma values
Definition: gensvm_grid.h:89
GenTask::lambda
double lambda
lambda parameter for the GenModel
Definition: gensvm_task.h:68
gensvm_free_data
void gensvm_free_data(struct GenData *data)
Free allocated GenData struct.
Definition: gensvm_base.c:73
gensvm_free_queue
void gensvm_free_queue(struct GenQueue *q)
Free the GenQueue struct.
Definition: gensvm_queue.c:59
GenTask
A structure for a single task in the queue.
Definition: gensvm_task.h:55
K_SIGMOID
Definition: gensvm_globals.h:71
gensvm_kernel_changed
bool gensvm_kernel_changed(struct GenTask *newtask, struct GenTask *oldtask)
Check if the kernel parameters change between tasks.
Definition: gensvm_gridsearch.c:195
gensvm_free_task
void gensvm_free_task(struct GenTask *t)
Free the GenTask struct.
Definition: gensvm_task.c:71
RUN_TESTS
RUN_TESTS(all_tests)
GenQueue::tasks
struct GenTask ** tasks
array of pointers to Task structs
Definition: gensvm_queue.h:48
GenGrid::weight_idxs
int * weight_idxs
array of weight_idxs
Definition: gensvm_grid.h:95
GenTask::kappa
double kappa
kappa parameter for the GenModel
Definition: gensvm_task.h:66
GenGrid::gammas
double * gammas
array of gamma values
Definition: gensvm_grid.h:105
GENSVM_OUTPUT_FILE
FILE * GENSVM_OUTPUT_FILE
Definition: gensvm_print.c:33
GenGrid::coefs
double * coefs
array of coef values
Definition: gensvm_grid.h:107
test_fill_queue_kernel
char * test_fill_queue_kernel()
Definition: test_gensvm_gridsearch.c:122
GenGrid::Nd
long Nd
size of the array of degree values
Definition: gensvm_grid.h:93
test_gridsearch_progress_linear
char * test_gridsearch_progress_linear()
Definition: test_gensvm_gridsearch.c:933
gensvm_init_data
struct GenData * gensvm_init_data(void)
Initialize a GenData structure.
Definition: gensvm_base.c:45
GenTask::epsilon
double epsilon
epsilon parameter for the GenModel
Definition: gensvm_task.h:70
mu_suite_start
#define mu_suite_start()
Definition: minunit.h:24
GenGrid::ps
double * ps
array of p values
Definition: gensvm_grid.h:97
GenTask::p
double p
p parameter for the GenModel
Definition: gensvm_task.h:64
gensvm_free_grid
void gensvm_free_grid(struct GenGrid *grid)
Free a GenGrid structure.
Definition: gensvm_grid.c:88
GenTask::train_data
struct GenData * train_data
pointer to the training data
Definition: gensvm_task.h:80
GenTask::weight_idx
int weight_idx
weight_idx parameter for the GenModel
Definition: gensvm_task.h:58
gensvm_init_grid
struct GenGrid * gensvm_init_grid(void)
Initialize a GenGrid structure.
Definition: gensvm_grid.c:44
Generated on Tue Feb 21 2017 18:44:21 for GenSVM by   doxygen 1.8.13