1 /*
2 file automatically generated by make_test_files.pl
3 Tue Apr 19 14:01:03 2011
4 */
5
6 /*****************************************************************************
7 * *
8 * UNU.RAN -- Universal Non-Uniform Random number generator *
9 * *
10 *****************************************************************************/
11
12 /**
13 ** Tests for TDR
14 **/
15
16 /*---------------------------------------------------------------------------*/
17 #include "testunuran.h"
18
19 #ifdef UNUR_URNG_DEFAULT_RNGSTREAM
20 #include <RngStream.h>
21 #endif
22 /*---------------------------------------------------------------------------*/
23
24 /*---------------------------------------------------------------------------*/
25 /* global variables */
26
27 static FILE *TESTLOG; /* test log file */
28 static FILE *UNURANLOG; /* unuran log file */
29
30 static int test_ok = TRUE; /* all tests ok (boolean) */
31 static int fullcheck = FALSE; /* whether all checks are performed */
32
33 static TIMER watch; /* stop watch */
34
35 /*---------------------------------------------------------------------------*/
36
37 void run_verify_generator( FILE *LOG, int line, UNUR_PAR *par );
38
39
40
41 /*---------------------------------------------------------------------------*/
42
43 void test_new (void);
44 void test_set (void);
45 void test_get (void);
46 void test_chg (void);
47 void test_init (void);
48 void test_reinit (void);
49 void test_sample (void);
50 void test_validate (void);
51 void test_special(void);
52
53 /*---------------------------------------------------------------------------*/
54
55
56
57 /* prototypes */
58
59 double pdf_sqrtlin( double x, const UNUR_DISTR *distr );
60 double dpdf_sqrtlin( double x, const UNUR_DISTR *distr );
61 double cdf_sqrtlin( double x, const UNUR_DISTR *distr );
62
63 double pdf_sqrtlinshft(double x, const UNUR_DISTR *distr );
64 double dpdf_sqrtlinshft( double x, const UNUR_DISTR *distr );
65 double cdf_sqrtlinshft( double x, const UNUR_DISTR *distr );
66
67 #define COMPARE_SAMPLE_SIZE (10000)
68 #define VIOLATE_SAMPLE_SIZE (20)
69
70
71
72
73 /*---------------------------------------------------------------------------*/
74
75 #ifndef CHI2_FAILURES_TOLERATED
76 # define CHI2_FAILURES_TOLERATED DEFAULT_CHI2_FAILURES_TOLERATED
77 #endif
78
79 /*---------------------------------------------------------------------------*/
80 /* [verbatim] */
81
82
83
84 /* pdf with piecewise linear function as transformed density with T = -1/sqrt */
pdf_sqrtlin(double x,const UNUR_DISTR * distr ATTRIBUTE__UNUSED)85 double pdf_sqrtlin( double x, const UNUR_DISTR *distr ATTRIBUTE__UNUSED)
86 {
87 double y = 1./(fabs(x)+1.);
88 return y*y;
89 }
dpdf_sqrtlin(double x,const UNUR_DISTR * distr ATTRIBUTE__UNUSED)90 double dpdf_sqrtlin( double x, const UNUR_DISTR *distr ATTRIBUTE__UNUSED)
91 {
92 double y = 1./(fabs(x)+1.);
93 y = 2.*y*y*y;
94 return ((x<0.) ? y : - y);
95 }
cdf_sqrtlin(double x,const UNUR_DISTR * distr ATTRIBUTE__UNUSED)96 double cdf_sqrtlin( double x, const UNUR_DISTR *distr ATTRIBUTE__UNUSED)
97 {
98 if (x<=0.)
99 return 0.5/(1.-x);
100 else
101 return (1.-0.5/(1.+x));
102 }
103
104 /* pdf with piecewise linear function as transformed density with T = -1/sqrt and shifted mode */
pdf_sqrtlinshft(double x,const UNUR_DISTR * distr ATTRIBUTE__UNUSED)105 double pdf_sqrtlinshft( double x, const UNUR_DISTR *distr ATTRIBUTE__UNUSED)
106 {
107 double y;
108 x -= 1000.;
109 y = 1./(fabs(x)+1.);
110 return y*y;
111 }
dpdf_sqrtlinshft(double x,const UNUR_DISTR * distr ATTRIBUTE__UNUSED)112 double dpdf_sqrtlinshft( double x, const UNUR_DISTR *distr ATTRIBUTE__UNUSED)
113 {
114 double y;
115 x -= 1000.;
116 y = 1./(fabs(x)+1.);
117 y = 2.*y*y*y;
118 return ((x<0.) ? y : - y);
119 }
cdf_sqrtlinshft(double x,const UNUR_DISTR * distr ATTRIBUTE__UNUSED)120 double cdf_sqrtlinshft( double x, const UNUR_DISTR *distr ATTRIBUTE__UNUSED)
121 {
122 x -= 1000.;
123 if (x<=0.)
124 return 0.5/(1.-x);
125 else
126 return (1.-0.5/(1.+x));
127 }
128
129 /*---------------------------------------------------------------------------*/
130 /* [new] */
131
test_new(void)132 void test_new (void)
133 {
134 int n_tests_failed; /* number of failed tests */
135
136 /* start test */
137 printf("[new "); fflush(stdout);
138 fprintf(TESTLOG,"\n[new]\n");
139
140 /* reset counter */
141 n_tests_failed = 0;
142
143 /* set stop watch */
144 stopwatch_lap(&watch);
145
146
147 /* timing */
148 stopwatch_print(TESTLOG,"\n<*>time = %.3f ms\n\n", stopwatch_lap(&watch));
149
150 /* test finished */
151 test_ok &= (n_tests_failed) ? 0 : 1;
152 (n_tests_failed) ? printf(" ==> failed] ") : printf(" ==> ok] ");
153
154 } /* end of test_new() */
155
156 /*---------------------------------------------------------------------------*/
157 /* [validate] */
158
159 /*---------------------------------------------------------------------------*/
160
161 /* [validate] */
162
test_validate(void)163 void test_validate (void)
164 {
165 UNUR_DISTR *distr[32];
166 UNUR_PAR *par;
167 UNUR_GEN *gen;
168 int n_tests_failed;
169 int rcode;
170 double *darray;
171 double fpm[10];
172
173 rcode = 0;
174
175 /* start test */
176 printf("[validate "); fflush(stdout);
177 fprintf(TESTLOG,"\n[validate]\n");
178
179 /* reset counter */
180 n_tests_failed = 0;
181
182 /* set stop watch */
183 stopwatch_lap(&watch);
184
185
186 /* distributions: 32 */
187 {
188 fpm[0] = 1.;
189 fpm[1] = 2.;
190 distr[0] = unur_distr_beta(fpm,2);
191 }
192
193 {
194 fpm[0] = 1.;
195 fpm[1] = 5.;
196 distr[1] = unur_distr_beta(fpm,2);
197 }
198
199 {
200 fpm[0] = 1.;
201 fpm[1] = 100.;
202 distr[2] = unur_distr_beta(fpm,2);
203 }
204
205 {
206 fpm[0] = 2.;
207 fpm[1] = 5.;
208 distr[30] = unur_distr_beta(fpm,2);
209 }
210
211 {
212 fpm[0] = 5.;
213 fpm[1] = 2.;
214 distr[31] = unur_distr_beta(fpm,2);
215 }
216
217 {
218 fpm[0] = 3.;
219 fpm[1] = 4.;
220 distr[3] = unur_distr_beta(fpm,2);
221 }
222
223 {
224 fpm[0] = 5.;
225 fpm[1] = 100.;
226 distr[4] = unur_distr_beta(fpm,2);
227 }
228
229 {
230 fpm[0] = 500.;
231 fpm[1] = 300.;
232 distr[5] = unur_distr_beta(fpm,2);
233 }
234
235 {
236 fpm[0] = 5.;
237 fpm[1] = 10.;
238 fpm[2] = -3.;
239 fpm[3] = 15.;
240 distr[6] = unur_distr_beta(fpm,4);
241 }
242
243 {
244 distr[7] = unur_distr_cauchy(NULL,0);
245 }
246
247 {
248 fpm[0] = 1.;
249 fpm[1] = 20.;
250 distr[8] = unur_distr_cauchy(fpm,2);
251 }
252
253 {
254 distr[24] = unur_distr_exponential(NULL,0);
255 }
256
257 {
258 fpm[0] = 30.;
259 fpm[1] = -5.;
260 distr[25] = unur_distr_exponential(fpm,2);
261 }
262
263 {
264 fpm[0] = 1.;
265 distr[9] = unur_distr_gamma(fpm,1);
266 }
267
268 {
269 fpm[0] = 2.;
270 distr[10] = unur_distr_gamma(fpm,1);
271 }
272
273 {
274 fpm[0] = 3.;
275 distr[11] = unur_distr_gamma(fpm,1);
276 }
277
278 {
279 fpm[0] = 10.;
280 distr[12] = unur_distr_gamma(fpm,1);
281 }
282
283 {
284 fpm[0] = 1000.;
285 distr[13] = unur_distr_gamma(fpm,1);
286 }
287
288 {
289 fpm[0] = 5.;
290 fpm[1] = 1000.;
291 distr[14] = unur_distr_gamma(fpm,2);
292 }
293
294 {
295 fpm[0] = 5.;
296 fpm[1] = 1.e-5;
297 distr[15] = unur_distr_gamma(fpm,2);
298 }
299
300 {
301 fpm[0] = 5.;
302 fpm[1] = 10.;
303 fpm[2] = 1000.;
304 distr[16] = unur_distr_gamma(fpm,3);
305 }
306
307 {
308 distr[26] = unur_distr_laplace(NULL,0);
309 }
310
311 {
312 fpm[0] = -10.;
313 fpm[1] = 100.;
314 distr[27] = unur_distr_laplace(fpm,2);
315 }
316
317 {
318 distr[17] = unur_distr_normal(NULL,0);
319 }
320
321 {
322 fpm[0] = 1.;
323 fpm[1] = 1.e-5;
324 distr[18] = unur_distr_normal(fpm,2);
325 }
326
327 {
328 fpm[0] = 0.;
329 fpm[1] = 1.e+5;
330 distr[19] = unur_distr_normal(fpm,2);
331 }
332
333 {
334 distr[20] = unur_distr_uniform(NULL,0);
335 }
336
337 {
338 fpm[0] = 1.;
339 fpm[1] = 20.;
340 distr[21] = unur_distr_uniform(fpm,2);
341 }
342
343 {
344 distr[28] = unur_distr_cont_new();
345 unur_distr_cont_set_pdf(distr[28],pdf_sqrtlin);
346 unur_distr_cont_set_dpdf(distr[28],dpdf_sqrtlin);
347 unur_distr_cont_set_cdf(distr[28],cdf_sqrtlin);
348 unur_distr_set_name(distr[28],"sqrtlin");
349 }
350
351 {
352 distr[29] = unur_distr_cont_new();
353 unur_distr_cont_set_pdf(distr[29],pdf_sqrtlinshft);
354 unur_distr_cont_set_dpdf(distr[29],dpdf_sqrtlinshft);
355 unur_distr_cont_set_cdf(distr[29],cdf_sqrtlinshft);
356 unur_distr_set_name(distr[29],"sqrtlin");
357 }
358
359 {
360 distr[22] = unur_distr_cauchy(NULL,0);
361 unur_distr_cont_set_domain(distr[22],0.1,1.);
362 unur_distr_cont_upd_mode(distr[22]);
363 unur_distr_cont_upd_pdfarea(distr[22]);
364 }
365
366 {
367 fpm[0] = 3.;
368 fpm[1] = 4.;
369 distr[23] = unur_distr_beta(fpm,2);
370 unur_distr_cont_set_domain(distr[23],-2.,5.);
371 }
372
373 /* timing */
374 stopwatch_print(TESTLOG,"\n<*>setup time = %.3f ms\n", stopwatch_lap(&watch));
375
376 printf("\n(chi^2) "); fflush(stdout);
377
378 /* chi^2 tests: 192 */
379
380 unur_set_default_debug(~UNUR_DEBUG_SAMPLE);
381 fprintf( TESTLOG,"\nChi^2 Test:\n");
382
383 /* distribution [0] */
384
385 if(fullcheck) {
386 unur_reset_errno();
387 do {
388 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[0]);
389 par = unur_tdr_new(distr_localcopy);
390 unur_tdr_set_variant_ia(par);
391 unur_tdr_set_c(par,-0.5);
392 gen = unur_init(par);
393 rcode = run_validate_chi2(TESTLOG,0,gen,distr[0],'+');
394 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
395 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
396 unur_free(gen);
397 unur_distr_free(distr_localcopy);
398 } while (0);
399 }
400
401 if(fullcheck) {
402 unur_reset_errno();
403 do {
404 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[0]);
405 par = unur_tdr_new(distr_localcopy);
406 unur_tdr_set_variant_ia(par);
407 unur_tdr_set_c(par,-0.5);
408 unur_tdr_set_usedars(par,FALSE);
409 unur_tdr_set_cpoints(par,10,NULL);
410 gen = unur_init(par);
411 rcode = run_validate_chi2(TESTLOG,0,gen,distr[0],'+');
412 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
413 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
414 unur_free(gen);
415 unur_distr_free(distr_localcopy);
416 } while (0);
417 }
418
419 if(fullcheck) {
420 unur_reset_errno();
421 do {
422 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[0]);
423 par = unur_tdr_new(distr_localcopy);
424 unur_tdr_set_variant_ia(par);
425 unur_tdr_set_c(par,-0.5);
426 unur_tdr_set_usedars(par,FALSE);
427 unur_tdr_set_cpoints(par,10,NULL);
428 unur_tdr_set_max_sqhratio(par,0.25);
429 gen = unur_init(par);
430 rcode = run_validate_chi2(TESTLOG,0,gen,distr[0],'+');
431 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
432 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
433 unur_free(gen);
434 unur_distr_free(distr_localcopy);
435 } while (0);
436 }
437
438 if(fullcheck) {
439 unur_reset_errno();
440 do {
441 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[0]);
442 par = unur_tdr_new(distr_localcopy);
443 unur_tdr_set_variant_ia(par);
444 unur_tdr_set_c(par,0.);
445 gen = unur_init(par);
446 rcode = run_validate_chi2(TESTLOG,0,gen,distr[0],'+');
447 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
448 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
449 unur_free(gen);
450 unur_distr_free(distr_localcopy);
451 } while (0);
452 }
453
454 if(fullcheck) {
455 unur_reset_errno();
456 do {
457 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[0]);
458 par = unur_tdr_new(distr_localcopy);
459 unur_tdr_set_variant_ia(par);
460 unur_tdr_set_c(par,-0.5);
461 unur_tdr_set_cpoints(par,30,NULL);
462 unur_set_use_distr_privatecopy(par,FALSE);
463 fpm[0] = 1.;
464 fpm[1] = 4.;
465 unur_distr_cont_set_pdfparams(distr_localcopy,fpm,2);
466 gen = unur_init(par);
467 if (gen) {
468 unur_tdr_chg_reinit_percentiles(gen, 2, NULL );
469 unur_reinit(gen);
470 }
471 rcode = run_validate_chi2(TESTLOG,0,gen,distr[0],'+');
472 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
473 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
474 unur_free(gen);
475 unur_distr_free(distr_localcopy);
476 } while (0);
477 }
478
479 if(fullcheck) {
480 unur_reset_errno();
481 do {
482 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[0]);
483 par = unur_tdr_new(distr_localcopy);
484 unur_tdr_set_variant_ia(par);
485 unur_tdr_set_c(par,0.);
486 unur_tdr_set_cpoints(par,30,NULL);
487 unur_set_use_distr_privatecopy(par,FALSE);
488 fpm[0] = 1.;
489 fpm[1] = 4.;
490 unur_distr_cont_set_pdfparams(distr_localcopy,fpm,2);
491 gen = unur_init(par);
492 if (gen) {
493 unur_tdr_chg_reinit_percentiles(gen, 2, NULL );
494 unur_reinit(gen);
495 }
496 rcode = run_validate_chi2(TESTLOG,0,gen,distr[0],'+');
497 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
498 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
499 unur_free(gen);
500 unur_distr_free(distr_localcopy);
501 } while (0);
502 }
503
504 /* distribution [1] */
505
506 if(TRUE) {
507 unur_reset_errno();
508 do {
509 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[1]);
510 par = unur_tdr_new(distr_localcopy);
511 unur_tdr_set_variant_ia(par);
512 unur_tdr_set_c(par,-0.5);
513 gen = unur_init(par);
514 rcode = run_validate_chi2(TESTLOG,0,gen,distr[1],'+');
515 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
516 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
517 unur_free(gen);
518 unur_distr_free(distr_localcopy);
519 } while (0);
520 }
521
522 if(TRUE) {
523 unur_reset_errno();
524 do {
525 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[1]);
526 par = unur_tdr_new(distr_localcopy);
527 unur_tdr_set_variant_ia(par);
528 unur_tdr_set_c(par,-0.5);
529 unur_tdr_set_usedars(par,FALSE);
530 unur_tdr_set_cpoints(par,10,NULL);
531 gen = unur_init(par);
532 rcode = run_validate_chi2(TESTLOG,0,gen,distr[1],'+');
533 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
534 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
535 unur_free(gen);
536 unur_distr_free(distr_localcopy);
537 } while (0);
538 }
539
540 if(TRUE) {
541 unur_reset_errno();
542 do {
543 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[1]);
544 par = unur_tdr_new(distr_localcopy);
545 unur_tdr_set_variant_ia(par);
546 unur_tdr_set_c(par,-0.5);
547 unur_tdr_set_usedars(par,FALSE);
548 unur_tdr_set_cpoints(par,10,NULL);
549 unur_tdr_set_max_sqhratio(par,0.25);
550 gen = unur_init(par);
551 rcode = run_validate_chi2(TESTLOG,0,gen,distr[1],'+');
552 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
553 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
554 unur_free(gen);
555 unur_distr_free(distr_localcopy);
556 } while (0);
557 }
558
559 if(TRUE) {
560 unur_reset_errno();
561 do {
562 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[1]);
563 par = unur_tdr_new(distr_localcopy);
564 unur_tdr_set_variant_ia(par);
565 unur_tdr_set_c(par,0.);
566 gen = unur_init(par);
567 rcode = run_validate_chi2(TESTLOG,0,gen,distr[1],'+');
568 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
569 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
570 unur_free(gen);
571 unur_distr_free(distr_localcopy);
572 } while (0);
573 }
574
575 if(TRUE) {
576 printf("."); fflush(stdout);
577 }
578
579 if(TRUE) {
580 printf("."); fflush(stdout);
581 }
582
583 /* distribution [2] */
584
585 if(fullcheck) {
586 unur_reset_errno();
587 do {
588 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[2]);
589 par = unur_tdr_new(distr_localcopy);
590 unur_tdr_set_variant_ia(par);
591 unur_tdr_set_c(par,-0.5);
592 gen = unur_init(par);
593 rcode = run_validate_chi2(TESTLOG,0,gen,distr[2],'+');
594 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
595 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
596 unur_free(gen);
597 unur_distr_free(distr_localcopy);
598 } while (0);
599 }
600
601 if(fullcheck) {
602 unur_reset_errno();
603 do {
604 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[2]);
605 par = unur_tdr_new(distr_localcopy);
606 unur_tdr_set_variant_ia(par);
607 unur_tdr_set_c(par,-0.5);
608 unur_tdr_set_usedars(par,FALSE);
609 unur_tdr_set_cpoints(par,10,NULL);
610 gen = unur_init(par);
611 rcode = run_validate_chi2(TESTLOG,0,gen,distr[2],'+');
612 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
613 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
614 unur_free(gen);
615 unur_distr_free(distr_localcopy);
616 } while (0);
617 }
618
619 if(fullcheck) {
620 unur_reset_errno();
621 do {
622 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[2]);
623 par = unur_tdr_new(distr_localcopy);
624 unur_tdr_set_variant_ia(par);
625 unur_tdr_set_c(par,-0.5);
626 unur_tdr_set_usedars(par,FALSE);
627 unur_tdr_set_cpoints(par,10,NULL);
628 unur_tdr_set_max_sqhratio(par,0.25);
629 gen = unur_init(par);
630 rcode = run_validate_chi2(TESTLOG,0,gen,distr[2],'+');
631 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
632 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
633 unur_free(gen);
634 unur_distr_free(distr_localcopy);
635 } while (0);
636 }
637
638 if(fullcheck) {
639 unur_reset_errno();
640 do {
641 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[2]);
642 par = unur_tdr_new(distr_localcopy);
643 unur_tdr_set_variant_ia(par);
644 unur_tdr_set_c(par,0.);
645 gen = unur_init(par);
646 rcode = run_validate_chi2(TESTLOG,0,gen,distr[2],'+');
647 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
648 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
649 unur_free(gen);
650 unur_distr_free(distr_localcopy);
651 } while (0);
652 }
653
654 if(fullcheck) {
655 unur_reset_errno();
656 do {
657 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[2]);
658 par = unur_tdr_new(distr_localcopy);
659 unur_tdr_set_variant_ia(par);
660 unur_tdr_set_c(par,-0.5);
661 unur_tdr_set_cpoints(par,30,NULL);
662 unur_set_use_distr_privatecopy(par,FALSE);
663 fpm[0] = 1.;
664 fpm[1] = 4.;
665 unur_distr_cont_set_pdfparams(distr_localcopy,fpm,2);
666 gen = unur_init(par);
667 if (gen) {
668 unur_tdr_chg_reinit_percentiles(gen, 2, NULL );
669 unur_reinit(gen);
670 }
671 rcode = run_validate_chi2(TESTLOG,0,gen,distr[2],'+');
672 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
673 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
674 unur_free(gen);
675 unur_distr_free(distr_localcopy);
676 } while (0);
677 }
678
679 if(fullcheck) {
680 unur_reset_errno();
681 do {
682 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[2]);
683 par = unur_tdr_new(distr_localcopy);
684 unur_tdr_set_variant_ia(par);
685 unur_tdr_set_c(par,0.);
686 unur_tdr_set_cpoints(par,30,NULL);
687 unur_set_use_distr_privatecopy(par,FALSE);
688 fpm[0] = 1.;
689 fpm[1] = 4.;
690 unur_distr_cont_set_pdfparams(distr_localcopy,fpm,2);
691 gen = unur_init(par);
692 if (gen) {
693 unur_tdr_chg_reinit_percentiles(gen, 2, NULL );
694 unur_reinit(gen);
695 }
696 rcode = run_validate_chi2(TESTLOG,0,gen,distr[2],'+');
697 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
698 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
699 unur_free(gen);
700 unur_distr_free(distr_localcopy);
701 } while (0);
702 }
703
704 /* distribution [30] */
705
706 if(TRUE) {
707 unur_reset_errno();
708 do {
709 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[30]);
710 par = unur_tdr_new(distr_localcopy);
711 unur_tdr_set_variant_ia(par);
712 unur_tdr_set_c(par,-0.5);
713 gen = unur_init(par);
714 rcode = run_validate_chi2(TESTLOG,0,gen,distr[30],'+');
715 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
716 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
717 unur_free(gen);
718 unur_distr_free(distr_localcopy);
719 } while (0);
720 }
721
722 if(TRUE) {
723 unur_reset_errno();
724 do {
725 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[30]);
726 par = unur_tdr_new(distr_localcopy);
727 unur_tdr_set_variant_ia(par);
728 unur_tdr_set_c(par,-0.5);
729 unur_tdr_set_usedars(par,FALSE);
730 unur_tdr_set_cpoints(par,10,NULL);
731 gen = unur_init(par);
732 rcode = run_validate_chi2(TESTLOG,0,gen,distr[30],'+');
733 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
734 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
735 unur_free(gen);
736 unur_distr_free(distr_localcopy);
737 } while (0);
738 }
739
740 if(TRUE) {
741 unur_reset_errno();
742 do {
743 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[30]);
744 par = unur_tdr_new(distr_localcopy);
745 unur_tdr_set_variant_ia(par);
746 unur_tdr_set_c(par,-0.5);
747 unur_tdr_set_usedars(par,FALSE);
748 unur_tdr_set_cpoints(par,10,NULL);
749 unur_tdr_set_max_sqhratio(par,0.25);
750 gen = unur_init(par);
751 rcode = run_validate_chi2(TESTLOG,0,gen,distr[30],'+');
752 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
753 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
754 unur_free(gen);
755 unur_distr_free(distr_localcopy);
756 } while (0);
757 }
758
759 if(TRUE) {
760 unur_reset_errno();
761 do {
762 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[30]);
763 par = unur_tdr_new(distr_localcopy);
764 unur_tdr_set_variant_ia(par);
765 unur_tdr_set_c(par,0.);
766 gen = unur_init(par);
767 rcode = run_validate_chi2(TESTLOG,0,gen,distr[30],'+');
768 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
769 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
770 unur_free(gen);
771 unur_distr_free(distr_localcopy);
772 } while (0);
773 }
774
775 if(TRUE) {
776 printf("."); fflush(stdout);
777 }
778
779 if(TRUE) {
780 printf("."); fflush(stdout);
781 }
782
783 /* distribution [31] */
784
785 if(TRUE) {
786 unur_reset_errno();
787 do {
788 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[31]);
789 par = unur_tdr_new(distr_localcopy);
790 unur_tdr_set_variant_ia(par);
791 unur_tdr_set_c(par,-0.5);
792 gen = unur_init(par);
793 rcode = run_validate_chi2(TESTLOG,0,gen,distr[31],'+');
794 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
795 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
796 unur_free(gen);
797 unur_distr_free(distr_localcopy);
798 } while (0);
799 }
800
801 if(TRUE) {
802 unur_reset_errno();
803 do {
804 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[31]);
805 par = unur_tdr_new(distr_localcopy);
806 unur_tdr_set_variant_ia(par);
807 unur_tdr_set_c(par,-0.5);
808 unur_tdr_set_usedars(par,FALSE);
809 unur_tdr_set_cpoints(par,10,NULL);
810 gen = unur_init(par);
811 rcode = run_validate_chi2(TESTLOG,0,gen,distr[31],'+');
812 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
813 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
814 unur_free(gen);
815 unur_distr_free(distr_localcopy);
816 } while (0);
817 }
818
819 if(TRUE) {
820 unur_reset_errno();
821 do {
822 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[31]);
823 par = unur_tdr_new(distr_localcopy);
824 unur_tdr_set_variant_ia(par);
825 unur_tdr_set_c(par,-0.5);
826 unur_tdr_set_usedars(par,FALSE);
827 unur_tdr_set_cpoints(par,10,NULL);
828 unur_tdr_set_max_sqhratio(par,0.25);
829 gen = unur_init(par);
830 rcode = run_validate_chi2(TESTLOG,0,gen,distr[31],'+');
831 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
832 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
833 unur_free(gen);
834 unur_distr_free(distr_localcopy);
835 } while (0);
836 }
837
838 if(TRUE) {
839 unur_reset_errno();
840 do {
841 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[31]);
842 par = unur_tdr_new(distr_localcopy);
843 unur_tdr_set_variant_ia(par);
844 unur_tdr_set_c(par,0.);
845 gen = unur_init(par);
846 rcode = run_validate_chi2(TESTLOG,0,gen,distr[31],'+');
847 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
848 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
849 unur_free(gen);
850 unur_distr_free(distr_localcopy);
851 } while (0);
852 }
853
854 if(TRUE) {
855 unur_reset_errno();
856 do {
857 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[31]);
858 par = unur_tdr_new(distr_localcopy);
859 unur_tdr_set_variant_ia(par);
860 unur_tdr_set_c(par,-0.5);
861 unur_tdr_set_cpoints(par,30,NULL);
862 unur_set_use_distr_privatecopy(par,FALSE);
863 fpm[0] = 1.;
864 fpm[1] = 4.;
865 unur_distr_cont_set_pdfparams(distr_localcopy,fpm,2);
866 gen = unur_init(par);
867 if (gen) {
868 unur_tdr_chg_reinit_percentiles(gen, 2, NULL );
869 unur_reinit(gen);
870 }
871 rcode = run_validate_chi2(TESTLOG,0,gen,distr[31],'+');
872 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
873 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
874 unur_free(gen);
875 unur_distr_free(distr_localcopy);
876 } while (0);
877 }
878
879 if(TRUE) {
880 unur_reset_errno();
881 do {
882 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[31]);
883 par = unur_tdr_new(distr_localcopy);
884 unur_tdr_set_variant_ia(par);
885 unur_tdr_set_c(par,0.);
886 unur_tdr_set_cpoints(par,30,NULL);
887 unur_set_use_distr_privatecopy(par,FALSE);
888 fpm[0] = 1.;
889 fpm[1] = 4.;
890 unur_distr_cont_set_pdfparams(distr_localcopy,fpm,2);
891 gen = unur_init(par);
892 if (gen) {
893 unur_tdr_chg_reinit_percentiles(gen, 2, NULL );
894 unur_reinit(gen);
895 }
896 rcode = run_validate_chi2(TESTLOG,0,gen,distr[31],'+');
897 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
898 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
899 unur_free(gen);
900 unur_distr_free(distr_localcopy);
901 } while (0);
902 }
903
904 /* distribution [3] */
905
906 if(TRUE) {
907 unur_reset_errno();
908 do {
909 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[3]);
910 par = unur_tdr_new(distr_localcopy);
911 unur_tdr_set_variant_ia(par);
912 unur_tdr_set_c(par,-0.5);
913 gen = unur_init(par);
914 rcode = run_validate_chi2(TESTLOG,0,gen,distr[3],'+');
915 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
916 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
917 unur_free(gen);
918 unur_distr_free(distr_localcopy);
919 } while (0);
920 }
921
922 if(TRUE) {
923 unur_reset_errno();
924 do {
925 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[3]);
926 par = unur_tdr_new(distr_localcopy);
927 unur_tdr_set_variant_ia(par);
928 unur_tdr_set_c(par,-0.5);
929 unur_tdr_set_usedars(par,FALSE);
930 unur_tdr_set_cpoints(par,10,NULL);
931 gen = unur_init(par);
932 rcode = run_validate_chi2(TESTLOG,0,gen,distr[3],'+');
933 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
934 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
935 unur_free(gen);
936 unur_distr_free(distr_localcopy);
937 } while (0);
938 }
939
940 if(TRUE) {
941 unur_reset_errno();
942 do {
943 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[3]);
944 par = unur_tdr_new(distr_localcopy);
945 unur_tdr_set_variant_ia(par);
946 unur_tdr_set_c(par,-0.5);
947 unur_tdr_set_usedars(par,FALSE);
948 unur_tdr_set_cpoints(par,10,NULL);
949 unur_tdr_set_max_sqhratio(par,0.25);
950 gen = unur_init(par);
951 rcode = run_validate_chi2(TESTLOG,0,gen,distr[3],'+');
952 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
953 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
954 unur_free(gen);
955 unur_distr_free(distr_localcopy);
956 } while (0);
957 }
958
959 if(TRUE) {
960 unur_reset_errno();
961 do {
962 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[3]);
963 par = unur_tdr_new(distr_localcopy);
964 unur_tdr_set_variant_ia(par);
965 unur_tdr_set_c(par,0.);
966 gen = unur_init(par);
967 rcode = run_validate_chi2(TESTLOG,0,gen,distr[3],'+');
968 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
969 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
970 unur_free(gen);
971 unur_distr_free(distr_localcopy);
972 } while (0);
973 }
974
975 if(TRUE) {
976 printf("."); fflush(stdout);
977 }
978
979 if(TRUE) {
980 printf("."); fflush(stdout);
981 }
982
983 /* distribution [4] */
984
985 if(TRUE) {
986 unur_reset_errno();
987 do {
988 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[4]);
989 par = unur_tdr_new(distr_localcopy);
990 unur_tdr_set_variant_ia(par);
991 unur_tdr_set_c(par,-0.5);
992 gen = unur_init(par);
993 rcode = run_validate_chi2(TESTLOG,0,gen,distr[4],'+');
994 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
995 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
996 unur_free(gen);
997 unur_distr_free(distr_localcopy);
998 } while (0);
999 }
1000
1001 if(TRUE) {
1002 unur_reset_errno();
1003 do {
1004 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[4]);
1005 par = unur_tdr_new(distr_localcopy);
1006 unur_tdr_set_variant_ia(par);
1007 unur_tdr_set_c(par,-0.5);
1008 unur_tdr_set_usedars(par,FALSE);
1009 unur_tdr_set_cpoints(par,10,NULL);
1010 gen = unur_init(par);
1011 rcode = run_validate_chi2(TESTLOG,0,gen,distr[4],'+');
1012 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
1013 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
1014 unur_free(gen);
1015 unur_distr_free(distr_localcopy);
1016 } while (0);
1017 }
1018
1019 if(TRUE) {
1020 unur_reset_errno();
1021 do {
1022 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[4]);
1023 par = unur_tdr_new(distr_localcopy);
1024 unur_tdr_set_variant_ia(par);
1025 unur_tdr_set_c(par,-0.5);
1026 unur_tdr_set_usedars(par,FALSE);
1027 unur_tdr_set_cpoints(par,10,NULL);
1028 unur_tdr_set_max_sqhratio(par,0.25);
1029 gen = unur_init(par);
1030 rcode = run_validate_chi2(TESTLOG,0,gen,distr[4],'+');
1031 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
1032 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
1033 unur_free(gen);
1034 unur_distr_free(distr_localcopy);
1035 } while (0);
1036 }
1037
1038 if(TRUE) {
1039 unur_reset_errno();
1040 do {
1041 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[4]);
1042 par = unur_tdr_new(distr_localcopy);
1043 unur_tdr_set_variant_ia(par);
1044 unur_tdr_set_c(par,0.);
1045 gen = unur_init(par);
1046 rcode = run_validate_chi2(TESTLOG,0,gen,distr[4],'+');
1047 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
1048 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
1049 unur_free(gen);
1050 unur_distr_free(distr_localcopy);
1051 } while (0);
1052 }
1053
1054 if(TRUE) {
1055 printf("."); fflush(stdout);
1056 }
1057
1058 if(TRUE) {
1059 printf("."); fflush(stdout);
1060 }
1061
1062 /* distribution [5] */
1063
1064 if(TRUE) {
1065 unur_reset_errno();
1066 do {
1067 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[5]);
1068 par = unur_tdr_new(distr_localcopy);
1069 unur_tdr_set_variant_ia(par);
1070 unur_tdr_set_c(par,-0.5);
1071 gen = unur_init(par);
1072 rcode = run_validate_chi2(TESTLOG,0,gen,distr[5],'+');
1073 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
1074 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
1075 unur_free(gen);
1076 unur_distr_free(distr_localcopy);
1077 } while (0);
1078 }
1079
1080 if(TRUE) {
1081 unur_reset_errno();
1082 do {
1083 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[5]);
1084 par = unur_tdr_new(distr_localcopy);
1085 unur_tdr_set_variant_ia(par);
1086 unur_tdr_set_c(par,-0.5);
1087 unur_tdr_set_usedars(par,FALSE);
1088 unur_tdr_set_cpoints(par,10,NULL);
1089 gen = unur_init(par);
1090 rcode = run_validate_chi2(TESTLOG,0,gen,distr[5],'+');
1091 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
1092 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
1093 unur_free(gen);
1094 unur_distr_free(distr_localcopy);
1095 } while (0);
1096 }
1097
1098 if(TRUE) {
1099 unur_reset_errno();
1100 do {
1101 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[5]);
1102 par = unur_tdr_new(distr_localcopy);
1103 unur_tdr_set_variant_ia(par);
1104 unur_tdr_set_c(par,-0.5);
1105 unur_tdr_set_usedars(par,FALSE);
1106 unur_tdr_set_cpoints(par,10,NULL);
1107 unur_tdr_set_max_sqhratio(par,0.25);
1108 gen = unur_init(par);
1109 rcode = run_validate_chi2(TESTLOG,0,gen,distr[5],'+');
1110 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
1111 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
1112 unur_free(gen);
1113 unur_distr_free(distr_localcopy);
1114 } while (0);
1115 }
1116
1117 if(TRUE) {
1118 unur_reset_errno();
1119 do {
1120 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[5]);
1121 par = unur_tdr_new(distr_localcopy);
1122 unur_tdr_set_variant_ia(par);
1123 unur_tdr_set_c(par,0.);
1124 gen = unur_init(par);
1125 rcode = run_validate_chi2(TESTLOG,0,gen,distr[5],'+');
1126 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
1127 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
1128 unur_free(gen);
1129 unur_distr_free(distr_localcopy);
1130 } while (0);
1131 }
1132
1133 if(TRUE) {
1134 unur_reset_errno();
1135 do {
1136 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[5]);
1137 par = unur_tdr_new(distr_localcopy);
1138 unur_tdr_set_variant_ia(par);
1139 unur_tdr_set_c(par,-0.5);
1140 unur_tdr_set_cpoints(par,30,NULL);
1141 unur_set_use_distr_privatecopy(par,FALSE);
1142 fpm[0] = 1.;
1143 fpm[1] = 4.;
1144 unur_distr_cont_set_pdfparams(distr_localcopy,fpm,2);
1145 gen = unur_init(par);
1146 if (gen) {
1147 unur_tdr_chg_reinit_percentiles(gen, 2, NULL );
1148 unur_reinit(gen);
1149 }
1150 rcode = run_validate_chi2(TESTLOG,0,gen,distr[5],'+');
1151 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
1152 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
1153 unur_free(gen);
1154 unur_distr_free(distr_localcopy);
1155 } while (0);
1156 }
1157
1158 if(TRUE) {
1159 unur_reset_errno();
1160 do {
1161 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[5]);
1162 par = unur_tdr_new(distr_localcopy);
1163 unur_tdr_set_variant_ia(par);
1164 unur_tdr_set_c(par,0.);
1165 unur_tdr_set_cpoints(par,30,NULL);
1166 unur_set_use_distr_privatecopy(par,FALSE);
1167 fpm[0] = 1.;
1168 fpm[1] = 4.;
1169 unur_distr_cont_set_pdfparams(distr_localcopy,fpm,2);
1170 gen = unur_init(par);
1171 if (gen) {
1172 unur_tdr_chg_reinit_percentiles(gen, 2, NULL );
1173 unur_reinit(gen);
1174 }
1175 rcode = run_validate_chi2(TESTLOG,0,gen,distr[5],'+');
1176 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
1177 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
1178 unur_free(gen);
1179 unur_distr_free(distr_localcopy);
1180 } while (0);
1181 }
1182
1183 /* distribution [6] */
1184
1185 if(TRUE) {
1186 unur_reset_errno();
1187 do {
1188 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[6]);
1189 par = unur_tdr_new(distr_localcopy);
1190 unur_tdr_set_variant_ia(par);
1191 unur_tdr_set_c(par,-0.5);
1192 gen = unur_init(par);
1193 rcode = run_validate_chi2(TESTLOG,0,gen,distr[6],'+');
1194 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
1195 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
1196 unur_free(gen);
1197 unur_distr_free(distr_localcopy);
1198 } while (0);
1199 }
1200
1201 if(TRUE) {
1202 unur_reset_errno();
1203 do {
1204 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[6]);
1205 par = unur_tdr_new(distr_localcopy);
1206 unur_tdr_set_variant_ia(par);
1207 unur_tdr_set_c(par,-0.5);
1208 unur_tdr_set_usedars(par,FALSE);
1209 unur_tdr_set_cpoints(par,10,NULL);
1210 gen = unur_init(par);
1211 rcode = run_validate_chi2(TESTLOG,0,gen,distr[6],'+');
1212 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
1213 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
1214 unur_free(gen);
1215 unur_distr_free(distr_localcopy);
1216 } while (0);
1217 }
1218
1219 if(TRUE) {
1220 unur_reset_errno();
1221 do {
1222 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[6]);
1223 par = unur_tdr_new(distr_localcopy);
1224 unur_tdr_set_variant_ia(par);
1225 unur_tdr_set_c(par,-0.5);
1226 unur_tdr_set_usedars(par,FALSE);
1227 unur_tdr_set_cpoints(par,10,NULL);
1228 unur_tdr_set_max_sqhratio(par,0.25);
1229 gen = unur_init(par);
1230 rcode = run_validate_chi2(TESTLOG,0,gen,distr[6],'+');
1231 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
1232 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
1233 unur_free(gen);
1234 unur_distr_free(distr_localcopy);
1235 } while (0);
1236 }
1237
1238 if(TRUE) {
1239 unur_reset_errno();
1240 do {
1241 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[6]);
1242 par = unur_tdr_new(distr_localcopy);
1243 unur_tdr_set_variant_ia(par);
1244 unur_tdr_set_c(par,0.);
1245 gen = unur_init(par);
1246 rcode = run_validate_chi2(TESTLOG,0,gen,distr[6],'+');
1247 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
1248 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
1249 unur_free(gen);
1250 unur_distr_free(distr_localcopy);
1251 } while (0);
1252 }
1253
1254 if(TRUE) {
1255 unur_reset_errno();
1256 do {
1257 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[6]);
1258 par = unur_tdr_new(distr_localcopy);
1259 unur_tdr_set_variant_ia(par);
1260 unur_tdr_set_c(par,-0.5);
1261 unur_tdr_set_cpoints(par,30,NULL);
1262 unur_set_use_distr_privatecopy(par,FALSE);
1263 fpm[0] = 1.;
1264 fpm[1] = 4.;
1265 unur_distr_cont_set_pdfparams(distr_localcopy,fpm,2);
1266 gen = unur_init(par);
1267 if (gen) {
1268 unur_tdr_chg_reinit_percentiles(gen, 2, NULL );
1269 unur_reinit(gen);
1270 }
1271 rcode = run_validate_chi2(TESTLOG,0,gen,distr[6],'+');
1272 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
1273 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
1274 unur_free(gen);
1275 unur_distr_free(distr_localcopy);
1276 } while (0);
1277 }
1278
1279 if(TRUE) {
1280 unur_reset_errno();
1281 do {
1282 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[6]);
1283 par = unur_tdr_new(distr_localcopy);
1284 unur_tdr_set_variant_ia(par);
1285 unur_tdr_set_c(par,0.);
1286 unur_tdr_set_cpoints(par,30,NULL);
1287 unur_set_use_distr_privatecopy(par,FALSE);
1288 fpm[0] = 1.;
1289 fpm[1] = 4.;
1290 unur_distr_cont_set_pdfparams(distr_localcopy,fpm,2);
1291 gen = unur_init(par);
1292 if (gen) {
1293 unur_tdr_chg_reinit_percentiles(gen, 2, NULL );
1294 unur_reinit(gen);
1295 }
1296 rcode = run_validate_chi2(TESTLOG,0,gen,distr[6],'+');
1297 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
1298 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
1299 unur_free(gen);
1300 unur_distr_free(distr_localcopy);
1301 } while (0);
1302 }
1303
1304 /* distribution [7] */
1305
1306 if(TRUE) {
1307 unur_reset_errno();
1308 do {
1309 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[7]);
1310 par = unur_tdr_new(distr_localcopy);
1311 unur_tdr_set_variant_ia(par);
1312 unur_tdr_set_c(par,-0.5);
1313 gen = unur_init(par);
1314 rcode = run_validate_chi2(TESTLOG,0,gen,distr[7],'+');
1315 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
1316 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
1317 unur_free(gen);
1318 unur_distr_free(distr_localcopy);
1319 } while (0);
1320 }
1321
1322 if(TRUE) {
1323 unur_reset_errno();
1324 do {
1325 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[7]);
1326 par = unur_tdr_new(distr_localcopy);
1327 unur_tdr_set_variant_ia(par);
1328 unur_tdr_set_c(par,-0.5);
1329 unur_tdr_set_usedars(par,FALSE);
1330 unur_tdr_set_cpoints(par,10,NULL);
1331 gen = unur_init(par);
1332 rcode = run_validate_chi2(TESTLOG,0,gen,distr[7],'+');
1333 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
1334 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
1335 unur_free(gen);
1336 unur_distr_free(distr_localcopy);
1337 } while (0);
1338 }
1339
1340 if(TRUE) {
1341 unur_reset_errno();
1342 do {
1343 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[7]);
1344 par = unur_tdr_new(distr_localcopy);
1345 unur_tdr_set_variant_ia(par);
1346 unur_tdr_set_c(par,-0.5);
1347 unur_tdr_set_usedars(par,FALSE);
1348 unur_tdr_set_cpoints(par,10,NULL);
1349 unur_tdr_set_max_sqhratio(par,0.25);
1350 gen = unur_init(par);
1351 rcode = run_validate_chi2(TESTLOG,0,gen,distr[7],'+');
1352 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
1353 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
1354 unur_free(gen);
1355 unur_distr_free(distr_localcopy);
1356 } while (0);
1357 }
1358
1359 if(TRUE) {
1360 unur_reset_errno();
1361 do {
1362 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[7]);
1363 par = unur_tdr_new(distr_localcopy);
1364 unur_tdr_set_variant_ia(par);
1365 unur_tdr_set_c(par,0.);
1366 gen = unur_init(par);
1367 rcode = run_validate_chi2(TESTLOG,0,gen,distr[7],'0');
1368 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
1369 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
1370 unur_free(gen);
1371 unur_distr_free(distr_localcopy);
1372 } while (0);
1373 }
1374
1375 if(TRUE) {
1376 unur_reset_errno();
1377 do {
1378 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[7]);
1379 par = unur_tdr_new(distr_localcopy);
1380 unur_tdr_set_variant_ia(par);
1381 unur_tdr_set_c(par,-0.5);
1382 unur_tdr_set_cpoints(par,30,NULL);
1383 unur_set_use_distr_privatecopy(par,FALSE);
1384 fpm[0] = 1.;
1385 fpm[1] = 4.;
1386 unur_distr_cont_set_pdfparams(distr_localcopy,fpm,2);
1387 gen = unur_init(par);
1388 if (gen) {
1389 unur_tdr_chg_reinit_percentiles(gen, 2, NULL );
1390 unur_reinit(gen);
1391 }
1392 rcode = run_validate_chi2(TESTLOG,0,gen,distr[7],'+');
1393 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
1394 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
1395 unur_free(gen);
1396 unur_distr_free(distr_localcopy);
1397 } while (0);
1398 }
1399
1400 if(TRUE) {
1401 unur_reset_errno();
1402 do {
1403 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[7]);
1404 par = unur_tdr_new(distr_localcopy);
1405 unur_tdr_set_variant_ia(par);
1406 unur_tdr_set_c(par,0.);
1407 unur_tdr_set_cpoints(par,30,NULL);
1408 unur_set_use_distr_privatecopy(par,FALSE);
1409 fpm[0] = 1.;
1410 fpm[1] = 4.;
1411 unur_distr_cont_set_pdfparams(distr_localcopy,fpm,2);
1412 gen = unur_init(par);
1413 if (gen) {
1414 unur_tdr_chg_reinit_percentiles(gen, 2, NULL );
1415 unur_reinit(gen);
1416 }
1417 rcode = run_validate_chi2(TESTLOG,0,gen,distr[7],'0');
1418 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
1419 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
1420 unur_free(gen);
1421 unur_distr_free(distr_localcopy);
1422 } while (0);
1423 }
1424
1425 /* distribution [8] */
1426
1427 if(TRUE) {
1428 unur_reset_errno();
1429 do {
1430 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[8]);
1431 par = unur_tdr_new(distr_localcopy);
1432 unur_tdr_set_variant_ia(par);
1433 unur_tdr_set_c(par,-0.5);
1434 gen = unur_init(par);
1435 rcode = run_validate_chi2(TESTLOG,0,gen,distr[8],'+');
1436 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
1437 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
1438 unur_free(gen);
1439 unur_distr_free(distr_localcopy);
1440 } while (0);
1441 }
1442
1443 if(TRUE) {
1444 unur_reset_errno();
1445 do {
1446 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[8]);
1447 par = unur_tdr_new(distr_localcopy);
1448 unur_tdr_set_variant_ia(par);
1449 unur_tdr_set_c(par,-0.5);
1450 unur_tdr_set_usedars(par,FALSE);
1451 unur_tdr_set_cpoints(par,10,NULL);
1452 gen = unur_init(par);
1453 rcode = run_validate_chi2(TESTLOG,0,gen,distr[8],'+');
1454 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
1455 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
1456 unur_free(gen);
1457 unur_distr_free(distr_localcopy);
1458 } while (0);
1459 }
1460
1461 if(TRUE) {
1462 unur_reset_errno();
1463 do {
1464 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[8]);
1465 par = unur_tdr_new(distr_localcopy);
1466 unur_tdr_set_variant_ia(par);
1467 unur_tdr_set_c(par,-0.5);
1468 unur_tdr_set_usedars(par,FALSE);
1469 unur_tdr_set_cpoints(par,10,NULL);
1470 unur_tdr_set_max_sqhratio(par,0.25);
1471 gen = unur_init(par);
1472 rcode = run_validate_chi2(TESTLOG,0,gen,distr[8],'+');
1473 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
1474 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
1475 unur_free(gen);
1476 unur_distr_free(distr_localcopy);
1477 } while (0);
1478 }
1479
1480 if(TRUE) {
1481 unur_reset_errno();
1482 do {
1483 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[8]);
1484 par = unur_tdr_new(distr_localcopy);
1485 unur_tdr_set_variant_ia(par);
1486 unur_tdr_set_c(par,0.);
1487 gen = unur_init(par);
1488 rcode = run_validate_chi2(TESTLOG,0,gen,distr[8],'0');
1489 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
1490 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
1491 unur_free(gen);
1492 unur_distr_free(distr_localcopy);
1493 } while (0);
1494 }
1495
1496 if(TRUE) {
1497 unur_reset_errno();
1498 do {
1499 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[8]);
1500 par = unur_tdr_new(distr_localcopy);
1501 unur_tdr_set_variant_ia(par);
1502 unur_tdr_set_c(par,-0.5);
1503 unur_tdr_set_cpoints(par,30,NULL);
1504 unur_set_use_distr_privatecopy(par,FALSE);
1505 fpm[0] = 1.;
1506 fpm[1] = 4.;
1507 unur_distr_cont_set_pdfparams(distr_localcopy,fpm,2);
1508 gen = unur_init(par);
1509 if (gen) {
1510 unur_tdr_chg_reinit_percentiles(gen, 2, NULL );
1511 unur_reinit(gen);
1512 }
1513 rcode = run_validate_chi2(TESTLOG,0,gen,distr[8],'+');
1514 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
1515 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
1516 unur_free(gen);
1517 unur_distr_free(distr_localcopy);
1518 } while (0);
1519 }
1520
1521 if(TRUE) {
1522 unur_reset_errno();
1523 do {
1524 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[8]);
1525 par = unur_tdr_new(distr_localcopy);
1526 unur_tdr_set_variant_ia(par);
1527 unur_tdr_set_c(par,0.);
1528 unur_tdr_set_cpoints(par,30,NULL);
1529 unur_set_use_distr_privatecopy(par,FALSE);
1530 fpm[0] = 1.;
1531 fpm[1] = 4.;
1532 unur_distr_cont_set_pdfparams(distr_localcopy,fpm,2);
1533 gen = unur_init(par);
1534 if (gen) {
1535 unur_tdr_chg_reinit_percentiles(gen, 2, NULL );
1536 unur_reinit(gen);
1537 }
1538 rcode = run_validate_chi2(TESTLOG,0,gen,distr[8],'0');
1539 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
1540 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
1541 unur_free(gen);
1542 unur_distr_free(distr_localcopy);
1543 } while (0);
1544 }
1545
1546 /* distribution [24] */
1547
1548 if(TRUE) {
1549 unur_reset_errno();
1550 do {
1551 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[24]);
1552 par = unur_tdr_new(distr_localcopy);
1553 unur_tdr_set_variant_ia(par);
1554 unur_tdr_set_c(par,-0.5);
1555 gen = unur_init(par);
1556 rcode = run_validate_chi2(TESTLOG,0,gen,distr[24],'+');
1557 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
1558 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
1559 unur_free(gen);
1560 unur_distr_free(distr_localcopy);
1561 } while (0);
1562 }
1563
1564 if(TRUE) {
1565 unur_reset_errno();
1566 do {
1567 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[24]);
1568 par = unur_tdr_new(distr_localcopy);
1569 unur_tdr_set_variant_ia(par);
1570 unur_tdr_set_c(par,-0.5);
1571 unur_tdr_set_usedars(par,FALSE);
1572 unur_tdr_set_cpoints(par,10,NULL);
1573 gen = unur_init(par);
1574 rcode = run_validate_chi2(TESTLOG,0,gen,distr[24],'+');
1575 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
1576 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
1577 unur_free(gen);
1578 unur_distr_free(distr_localcopy);
1579 } while (0);
1580 }
1581
1582 if(TRUE) {
1583 unur_reset_errno();
1584 do {
1585 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[24]);
1586 par = unur_tdr_new(distr_localcopy);
1587 unur_tdr_set_variant_ia(par);
1588 unur_tdr_set_c(par,-0.5);
1589 unur_tdr_set_usedars(par,FALSE);
1590 unur_tdr_set_cpoints(par,10,NULL);
1591 unur_tdr_set_max_sqhratio(par,0.25);
1592 gen = unur_init(par);
1593 rcode = run_validate_chi2(TESTLOG,0,gen,distr[24],'+');
1594 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
1595 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
1596 unur_free(gen);
1597 unur_distr_free(distr_localcopy);
1598 } while (0);
1599 }
1600
1601 if(TRUE) {
1602 unur_reset_errno();
1603 do {
1604 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[24]);
1605 par = unur_tdr_new(distr_localcopy);
1606 unur_tdr_set_variant_ia(par);
1607 unur_tdr_set_c(par,0.);
1608 gen = unur_init(par);
1609 rcode = run_validate_chi2(TESTLOG,0,gen,distr[24],'+');
1610 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
1611 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
1612 unur_free(gen);
1613 unur_distr_free(distr_localcopy);
1614 } while (0);
1615 }
1616
1617 if(TRUE) {
1618 unur_reset_errno();
1619 do {
1620 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[24]);
1621 par = unur_tdr_new(distr_localcopy);
1622 unur_tdr_set_variant_ia(par);
1623 unur_tdr_set_c(par,-0.5);
1624 unur_tdr_set_cpoints(par,30,NULL);
1625 unur_set_use_distr_privatecopy(par,FALSE);
1626 fpm[0] = 1.;
1627 fpm[1] = 4.;
1628 unur_distr_cont_set_pdfparams(distr_localcopy,fpm,2);
1629 gen = unur_init(par);
1630 if (gen) {
1631 unur_tdr_chg_reinit_percentiles(gen, 2, NULL );
1632 unur_reinit(gen);
1633 }
1634 rcode = run_validate_chi2(TESTLOG,0,gen,distr[24],'+');
1635 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
1636 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
1637 unur_free(gen);
1638 unur_distr_free(distr_localcopy);
1639 } while (0);
1640 }
1641
1642 if(TRUE) {
1643 unur_reset_errno();
1644 do {
1645 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[24]);
1646 par = unur_tdr_new(distr_localcopy);
1647 unur_tdr_set_variant_ia(par);
1648 unur_tdr_set_c(par,0.);
1649 unur_tdr_set_cpoints(par,30,NULL);
1650 unur_set_use_distr_privatecopy(par,FALSE);
1651 fpm[0] = 1.;
1652 fpm[1] = 4.;
1653 unur_distr_cont_set_pdfparams(distr_localcopy,fpm,2);
1654 gen = unur_init(par);
1655 if (gen) {
1656 unur_tdr_chg_reinit_percentiles(gen, 2, NULL );
1657 unur_reinit(gen);
1658 }
1659 rcode = run_validate_chi2(TESTLOG,0,gen,distr[24],'+');
1660 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
1661 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
1662 unur_free(gen);
1663 unur_distr_free(distr_localcopy);
1664 } while (0);
1665 }
1666
1667 /* distribution [25] */
1668
1669 if(TRUE) {
1670 unur_reset_errno();
1671 do {
1672 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[25]);
1673 par = unur_tdr_new(distr_localcopy);
1674 unur_tdr_set_variant_ia(par);
1675 unur_tdr_set_c(par,-0.5);
1676 gen = unur_init(par);
1677 rcode = run_validate_chi2(TESTLOG,0,gen,distr[25],'+');
1678 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
1679 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
1680 unur_free(gen);
1681 unur_distr_free(distr_localcopy);
1682 } while (0);
1683 }
1684
1685 if(TRUE) {
1686 unur_reset_errno();
1687 do {
1688 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[25]);
1689 par = unur_tdr_new(distr_localcopy);
1690 unur_tdr_set_variant_ia(par);
1691 unur_tdr_set_c(par,-0.5);
1692 unur_tdr_set_usedars(par,FALSE);
1693 unur_tdr_set_cpoints(par,10,NULL);
1694 gen = unur_init(par);
1695 rcode = run_validate_chi2(TESTLOG,0,gen,distr[25],'+');
1696 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
1697 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
1698 unur_free(gen);
1699 unur_distr_free(distr_localcopy);
1700 } while (0);
1701 }
1702
1703 if(TRUE) {
1704 unur_reset_errno();
1705 do {
1706 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[25]);
1707 par = unur_tdr_new(distr_localcopy);
1708 unur_tdr_set_variant_ia(par);
1709 unur_tdr_set_c(par,-0.5);
1710 unur_tdr_set_usedars(par,FALSE);
1711 unur_tdr_set_cpoints(par,10,NULL);
1712 unur_tdr_set_max_sqhratio(par,0.25);
1713 gen = unur_init(par);
1714 rcode = run_validate_chi2(TESTLOG,0,gen,distr[25],'+');
1715 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
1716 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
1717 unur_free(gen);
1718 unur_distr_free(distr_localcopy);
1719 } while (0);
1720 }
1721
1722 if(TRUE) {
1723 unur_reset_errno();
1724 do {
1725 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[25]);
1726 par = unur_tdr_new(distr_localcopy);
1727 unur_tdr_set_variant_ia(par);
1728 unur_tdr_set_c(par,0.);
1729 gen = unur_init(par);
1730 rcode = run_validate_chi2(TESTLOG,0,gen,distr[25],'+');
1731 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
1732 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
1733 unur_free(gen);
1734 unur_distr_free(distr_localcopy);
1735 } while (0);
1736 }
1737
1738 if(TRUE) {
1739 unur_reset_errno();
1740 do {
1741 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[25]);
1742 par = unur_tdr_new(distr_localcopy);
1743 unur_tdr_set_variant_ia(par);
1744 unur_tdr_set_c(par,-0.5);
1745 unur_tdr_set_cpoints(par,30,NULL);
1746 unur_set_use_distr_privatecopy(par,FALSE);
1747 fpm[0] = 1.;
1748 fpm[1] = 4.;
1749 unur_distr_cont_set_pdfparams(distr_localcopy,fpm,2);
1750 gen = unur_init(par);
1751 if (gen) {
1752 unur_tdr_chg_reinit_percentiles(gen, 2, NULL );
1753 unur_reinit(gen);
1754 }
1755 rcode = run_validate_chi2(TESTLOG,0,gen,distr[25],'+');
1756 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
1757 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
1758 unur_free(gen);
1759 unur_distr_free(distr_localcopy);
1760 } while (0);
1761 }
1762
1763 if(TRUE) {
1764 unur_reset_errno();
1765 do {
1766 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[25]);
1767 par = unur_tdr_new(distr_localcopy);
1768 unur_tdr_set_variant_ia(par);
1769 unur_tdr_set_c(par,0.);
1770 unur_tdr_set_cpoints(par,30,NULL);
1771 unur_set_use_distr_privatecopy(par,FALSE);
1772 fpm[0] = 1.;
1773 fpm[1] = 4.;
1774 unur_distr_cont_set_pdfparams(distr_localcopy,fpm,2);
1775 gen = unur_init(par);
1776 if (gen) {
1777 unur_tdr_chg_reinit_percentiles(gen, 2, NULL );
1778 unur_reinit(gen);
1779 }
1780 rcode = run_validate_chi2(TESTLOG,0,gen,distr[25],'+');
1781 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
1782 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
1783 unur_free(gen);
1784 unur_distr_free(distr_localcopy);
1785 } while (0);
1786 }
1787
1788 /* distribution [9] */
1789
1790 if(fullcheck) {
1791 unur_reset_errno();
1792 do {
1793 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[9]);
1794 par = unur_tdr_new(distr_localcopy);
1795 unur_tdr_set_variant_ia(par);
1796 unur_tdr_set_c(par,-0.5);
1797 gen = unur_init(par);
1798 rcode = run_validate_chi2(TESTLOG,0,gen,distr[9],'+');
1799 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
1800 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
1801 unur_free(gen);
1802 unur_distr_free(distr_localcopy);
1803 } while (0);
1804 }
1805
1806 if(fullcheck) {
1807 unur_reset_errno();
1808 do {
1809 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[9]);
1810 par = unur_tdr_new(distr_localcopy);
1811 unur_tdr_set_variant_ia(par);
1812 unur_tdr_set_c(par,-0.5);
1813 unur_tdr_set_usedars(par,FALSE);
1814 unur_tdr_set_cpoints(par,10,NULL);
1815 gen = unur_init(par);
1816 rcode = run_validate_chi2(TESTLOG,0,gen,distr[9],'+');
1817 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
1818 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
1819 unur_free(gen);
1820 unur_distr_free(distr_localcopy);
1821 } while (0);
1822 }
1823
1824 if(fullcheck) {
1825 unur_reset_errno();
1826 do {
1827 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[9]);
1828 par = unur_tdr_new(distr_localcopy);
1829 unur_tdr_set_variant_ia(par);
1830 unur_tdr_set_c(par,-0.5);
1831 unur_tdr_set_usedars(par,FALSE);
1832 unur_tdr_set_cpoints(par,10,NULL);
1833 unur_tdr_set_max_sqhratio(par,0.25);
1834 gen = unur_init(par);
1835 rcode = run_validate_chi2(TESTLOG,0,gen,distr[9],'+');
1836 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
1837 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
1838 unur_free(gen);
1839 unur_distr_free(distr_localcopy);
1840 } while (0);
1841 }
1842
1843 if(fullcheck) {
1844 unur_reset_errno();
1845 do {
1846 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[9]);
1847 par = unur_tdr_new(distr_localcopy);
1848 unur_tdr_set_variant_ia(par);
1849 unur_tdr_set_c(par,0.);
1850 gen = unur_init(par);
1851 rcode = run_validate_chi2(TESTLOG,0,gen,distr[9],'+');
1852 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
1853 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
1854 unur_free(gen);
1855 unur_distr_free(distr_localcopy);
1856 } while (0);
1857 }
1858
1859 if(fullcheck) {
1860 printf("."); fflush(stdout);
1861 }
1862
1863 if(fullcheck) {
1864 printf("."); fflush(stdout);
1865 }
1866
1867 /* distribution [10] */
1868
1869 if(TRUE) {
1870 unur_reset_errno();
1871 do {
1872 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[10]);
1873 par = unur_tdr_new(distr_localcopy);
1874 unur_tdr_set_variant_ia(par);
1875 unur_tdr_set_c(par,-0.5);
1876 gen = unur_init(par);
1877 rcode = run_validate_chi2(TESTLOG,0,gen,distr[10],'+');
1878 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
1879 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
1880 unur_free(gen);
1881 unur_distr_free(distr_localcopy);
1882 } while (0);
1883 }
1884
1885 if(TRUE) {
1886 unur_reset_errno();
1887 do {
1888 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[10]);
1889 par = unur_tdr_new(distr_localcopy);
1890 unur_tdr_set_variant_ia(par);
1891 unur_tdr_set_c(par,-0.5);
1892 unur_tdr_set_usedars(par,FALSE);
1893 unur_tdr_set_cpoints(par,10,NULL);
1894 gen = unur_init(par);
1895 rcode = run_validate_chi2(TESTLOG,0,gen,distr[10],'+');
1896 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
1897 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
1898 unur_free(gen);
1899 unur_distr_free(distr_localcopy);
1900 } while (0);
1901 }
1902
1903 if(TRUE) {
1904 unur_reset_errno();
1905 do {
1906 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[10]);
1907 par = unur_tdr_new(distr_localcopy);
1908 unur_tdr_set_variant_ia(par);
1909 unur_tdr_set_c(par,-0.5);
1910 unur_tdr_set_usedars(par,FALSE);
1911 unur_tdr_set_cpoints(par,10,NULL);
1912 unur_tdr_set_max_sqhratio(par,0.25);
1913 gen = unur_init(par);
1914 rcode = run_validate_chi2(TESTLOG,0,gen,distr[10],'+');
1915 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
1916 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
1917 unur_free(gen);
1918 unur_distr_free(distr_localcopy);
1919 } while (0);
1920 }
1921
1922 if(TRUE) {
1923 unur_reset_errno();
1924 do {
1925 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[10]);
1926 par = unur_tdr_new(distr_localcopy);
1927 unur_tdr_set_variant_ia(par);
1928 unur_tdr_set_c(par,0.);
1929 gen = unur_init(par);
1930 rcode = run_validate_chi2(TESTLOG,0,gen,distr[10],'+');
1931 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
1932 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
1933 unur_free(gen);
1934 unur_distr_free(distr_localcopy);
1935 } while (0);
1936 }
1937
1938 if(TRUE) {
1939 unur_reset_errno();
1940 do {
1941 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[10]);
1942 par = unur_tdr_new(distr_localcopy);
1943 unur_tdr_set_variant_ia(par);
1944 unur_tdr_set_c(par,-0.5);
1945 unur_tdr_set_cpoints(par,30,NULL);
1946 unur_set_use_distr_privatecopy(par,FALSE);
1947 fpm[0] = 1.;
1948 fpm[1] = 4.;
1949 unur_distr_cont_set_pdfparams(distr_localcopy,fpm,2);
1950 gen = unur_init(par);
1951 if (gen) {
1952 unur_tdr_chg_reinit_percentiles(gen, 2, NULL );
1953 unur_reinit(gen);
1954 }
1955 rcode = run_validate_chi2(TESTLOG,0,gen,distr[10],'+');
1956 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
1957 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
1958 unur_free(gen);
1959 unur_distr_free(distr_localcopy);
1960 } while (0);
1961 }
1962
1963 if(TRUE) {
1964 unur_reset_errno();
1965 do {
1966 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[10]);
1967 par = unur_tdr_new(distr_localcopy);
1968 unur_tdr_set_variant_ia(par);
1969 unur_tdr_set_c(par,0.);
1970 unur_tdr_set_cpoints(par,30,NULL);
1971 unur_set_use_distr_privatecopy(par,FALSE);
1972 fpm[0] = 1.;
1973 fpm[1] = 4.;
1974 unur_distr_cont_set_pdfparams(distr_localcopy,fpm,2);
1975 gen = unur_init(par);
1976 if (gen) {
1977 unur_tdr_chg_reinit_percentiles(gen, 2, NULL );
1978 unur_reinit(gen);
1979 }
1980 rcode = run_validate_chi2(TESTLOG,0,gen,distr[10],'+');
1981 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
1982 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
1983 unur_free(gen);
1984 unur_distr_free(distr_localcopy);
1985 } while (0);
1986 }
1987
1988 /* distribution [11] */
1989
1990 if(TRUE) {
1991 unur_reset_errno();
1992 do {
1993 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[11]);
1994 par = unur_tdr_new(distr_localcopy);
1995 unur_tdr_set_variant_ia(par);
1996 unur_tdr_set_c(par,-0.5);
1997 gen = unur_init(par);
1998 rcode = run_validate_chi2(TESTLOG,0,gen,distr[11],'+');
1999 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
2000 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
2001 unur_free(gen);
2002 unur_distr_free(distr_localcopy);
2003 } while (0);
2004 }
2005
2006 if(TRUE) {
2007 unur_reset_errno();
2008 do {
2009 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[11]);
2010 par = unur_tdr_new(distr_localcopy);
2011 unur_tdr_set_variant_ia(par);
2012 unur_tdr_set_c(par,-0.5);
2013 unur_tdr_set_usedars(par,FALSE);
2014 unur_tdr_set_cpoints(par,10,NULL);
2015 gen = unur_init(par);
2016 rcode = run_validate_chi2(TESTLOG,0,gen,distr[11],'+');
2017 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
2018 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
2019 unur_free(gen);
2020 unur_distr_free(distr_localcopy);
2021 } while (0);
2022 }
2023
2024 if(TRUE) {
2025 unur_reset_errno();
2026 do {
2027 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[11]);
2028 par = unur_tdr_new(distr_localcopy);
2029 unur_tdr_set_variant_ia(par);
2030 unur_tdr_set_c(par,-0.5);
2031 unur_tdr_set_usedars(par,FALSE);
2032 unur_tdr_set_cpoints(par,10,NULL);
2033 unur_tdr_set_max_sqhratio(par,0.25);
2034 gen = unur_init(par);
2035 rcode = run_validate_chi2(TESTLOG,0,gen,distr[11],'+');
2036 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
2037 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
2038 unur_free(gen);
2039 unur_distr_free(distr_localcopy);
2040 } while (0);
2041 }
2042
2043 if(TRUE) {
2044 unur_reset_errno();
2045 do {
2046 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[11]);
2047 par = unur_tdr_new(distr_localcopy);
2048 unur_tdr_set_variant_ia(par);
2049 unur_tdr_set_c(par,0.);
2050 gen = unur_init(par);
2051 rcode = run_validate_chi2(TESTLOG,0,gen,distr[11],'+');
2052 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
2053 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
2054 unur_free(gen);
2055 unur_distr_free(distr_localcopy);
2056 } while (0);
2057 }
2058
2059 if(TRUE) {
2060 printf("."); fflush(stdout);
2061 }
2062
2063 if(TRUE) {
2064 printf("."); fflush(stdout);
2065 }
2066
2067 /* distribution [12] */
2068
2069 if(TRUE) {
2070 unur_reset_errno();
2071 do {
2072 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[12]);
2073 par = unur_tdr_new(distr_localcopy);
2074 unur_tdr_set_variant_ia(par);
2075 unur_tdr_set_c(par,-0.5);
2076 gen = unur_init(par);
2077 rcode = run_validate_chi2(TESTLOG,0,gen,distr[12],'+');
2078 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
2079 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
2080 unur_free(gen);
2081 unur_distr_free(distr_localcopy);
2082 } while (0);
2083 }
2084
2085 if(TRUE) {
2086 unur_reset_errno();
2087 do {
2088 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[12]);
2089 par = unur_tdr_new(distr_localcopy);
2090 unur_tdr_set_variant_ia(par);
2091 unur_tdr_set_c(par,-0.5);
2092 unur_tdr_set_usedars(par,FALSE);
2093 unur_tdr_set_cpoints(par,10,NULL);
2094 gen = unur_init(par);
2095 rcode = run_validate_chi2(TESTLOG,0,gen,distr[12],'+');
2096 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
2097 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
2098 unur_free(gen);
2099 unur_distr_free(distr_localcopy);
2100 } while (0);
2101 }
2102
2103 if(TRUE) {
2104 unur_reset_errno();
2105 do {
2106 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[12]);
2107 par = unur_tdr_new(distr_localcopy);
2108 unur_tdr_set_variant_ia(par);
2109 unur_tdr_set_c(par,-0.5);
2110 unur_tdr_set_usedars(par,FALSE);
2111 unur_tdr_set_cpoints(par,10,NULL);
2112 unur_tdr_set_max_sqhratio(par,0.25);
2113 gen = unur_init(par);
2114 rcode = run_validate_chi2(TESTLOG,0,gen,distr[12],'+');
2115 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
2116 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
2117 unur_free(gen);
2118 unur_distr_free(distr_localcopy);
2119 } while (0);
2120 }
2121
2122 if(TRUE) {
2123 unur_reset_errno();
2124 do {
2125 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[12]);
2126 par = unur_tdr_new(distr_localcopy);
2127 unur_tdr_set_variant_ia(par);
2128 unur_tdr_set_c(par,0.);
2129 gen = unur_init(par);
2130 rcode = run_validate_chi2(TESTLOG,0,gen,distr[12],'+');
2131 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
2132 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
2133 unur_free(gen);
2134 unur_distr_free(distr_localcopy);
2135 } while (0);
2136 }
2137
2138 if(TRUE) {
2139 printf("."); fflush(stdout);
2140 }
2141
2142 if(TRUE) {
2143 printf("."); fflush(stdout);
2144 }
2145
2146 /* distribution [13] */
2147
2148 if(fullcheck) {
2149 unur_reset_errno();
2150 do {
2151 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[13]);
2152 par = unur_tdr_new(distr_localcopy);
2153 unur_tdr_set_variant_ia(par);
2154 unur_tdr_set_c(par,-0.5);
2155 gen = unur_init(par);
2156 rcode = run_validate_chi2(TESTLOG,0,gen,distr[13],'+');
2157 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
2158 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
2159 unur_free(gen);
2160 unur_distr_free(distr_localcopy);
2161 } while (0);
2162 }
2163
2164 if(fullcheck) {
2165 unur_reset_errno();
2166 do {
2167 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[13]);
2168 par = unur_tdr_new(distr_localcopy);
2169 unur_tdr_set_variant_ia(par);
2170 unur_tdr_set_c(par,-0.5);
2171 unur_tdr_set_usedars(par,FALSE);
2172 unur_tdr_set_cpoints(par,10,NULL);
2173 gen = unur_init(par);
2174 rcode = run_validate_chi2(TESTLOG,0,gen,distr[13],'+');
2175 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
2176 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
2177 unur_free(gen);
2178 unur_distr_free(distr_localcopy);
2179 } while (0);
2180 }
2181
2182 if(fullcheck) {
2183 unur_reset_errno();
2184 do {
2185 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[13]);
2186 par = unur_tdr_new(distr_localcopy);
2187 unur_tdr_set_variant_ia(par);
2188 unur_tdr_set_c(par,-0.5);
2189 unur_tdr_set_usedars(par,FALSE);
2190 unur_tdr_set_cpoints(par,10,NULL);
2191 unur_tdr_set_max_sqhratio(par,0.25);
2192 gen = unur_init(par);
2193 rcode = run_validate_chi2(TESTLOG,0,gen,distr[13],'+');
2194 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
2195 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
2196 unur_free(gen);
2197 unur_distr_free(distr_localcopy);
2198 } while (0);
2199 }
2200
2201 if(fullcheck) {
2202 unur_reset_errno();
2203 do {
2204 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[13]);
2205 par = unur_tdr_new(distr_localcopy);
2206 unur_tdr_set_variant_ia(par);
2207 unur_tdr_set_c(par,0.);
2208 gen = unur_init(par);
2209 rcode = run_validate_chi2(TESTLOG,0,gen,distr[13],'+');
2210 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
2211 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
2212 unur_free(gen);
2213 unur_distr_free(distr_localcopy);
2214 } while (0);
2215 }
2216
2217 if(fullcheck) {
2218 printf("."); fflush(stdout);
2219 }
2220
2221 if(fullcheck) {
2222 printf("."); fflush(stdout);
2223 }
2224
2225 /* distribution [14] */
2226
2227 if(TRUE) {
2228 unur_reset_errno();
2229 do {
2230 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[14]);
2231 par = unur_tdr_new(distr_localcopy);
2232 unur_tdr_set_variant_ia(par);
2233 unur_tdr_set_c(par,-0.5);
2234 gen = unur_init(par);
2235 rcode = run_validate_chi2(TESTLOG,0,gen,distr[14],'+');
2236 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
2237 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
2238 unur_free(gen);
2239 unur_distr_free(distr_localcopy);
2240 } while (0);
2241 }
2242
2243 if(TRUE) {
2244 unur_reset_errno();
2245 do {
2246 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[14]);
2247 par = unur_tdr_new(distr_localcopy);
2248 unur_tdr_set_variant_ia(par);
2249 unur_tdr_set_c(par,-0.5);
2250 unur_tdr_set_usedars(par,FALSE);
2251 unur_tdr_set_cpoints(par,10,NULL);
2252 gen = unur_init(par);
2253 rcode = run_validate_chi2(TESTLOG,0,gen,distr[14],'+');
2254 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
2255 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
2256 unur_free(gen);
2257 unur_distr_free(distr_localcopy);
2258 } while (0);
2259 }
2260
2261 if(TRUE) {
2262 unur_reset_errno();
2263 do {
2264 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[14]);
2265 par = unur_tdr_new(distr_localcopy);
2266 unur_tdr_set_variant_ia(par);
2267 unur_tdr_set_c(par,-0.5);
2268 unur_tdr_set_usedars(par,FALSE);
2269 unur_tdr_set_cpoints(par,10,NULL);
2270 unur_tdr_set_max_sqhratio(par,0.25);
2271 gen = unur_init(par);
2272 rcode = run_validate_chi2(TESTLOG,0,gen,distr[14],'+');
2273 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
2274 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
2275 unur_free(gen);
2276 unur_distr_free(distr_localcopy);
2277 } while (0);
2278 }
2279
2280 if(TRUE) {
2281 unur_reset_errno();
2282 do {
2283 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[14]);
2284 par = unur_tdr_new(distr_localcopy);
2285 unur_tdr_set_variant_ia(par);
2286 unur_tdr_set_c(par,0.);
2287 gen = unur_init(par);
2288 rcode = run_validate_chi2(TESTLOG,0,gen,distr[14],'+');
2289 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
2290 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
2291 unur_free(gen);
2292 unur_distr_free(distr_localcopy);
2293 } while (0);
2294 }
2295
2296 if(TRUE) {
2297 printf("."); fflush(stdout);
2298 }
2299
2300 if(TRUE) {
2301 printf("."); fflush(stdout);
2302 }
2303
2304 /* distribution [15] */
2305
2306 if(fullcheck) {
2307 unur_reset_errno();
2308 do {
2309 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[15]);
2310 par = unur_tdr_new(distr_localcopy);
2311 unur_tdr_set_variant_ia(par);
2312 unur_tdr_set_c(par,-0.5);
2313 gen = unur_init(par);
2314 rcode = run_validate_chi2(TESTLOG,0,gen,distr[15],'+');
2315 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
2316 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
2317 unur_free(gen);
2318 unur_distr_free(distr_localcopy);
2319 } while (0);
2320 }
2321
2322 if(fullcheck) {
2323 unur_reset_errno();
2324 do {
2325 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[15]);
2326 par = unur_tdr_new(distr_localcopy);
2327 unur_tdr_set_variant_ia(par);
2328 unur_tdr_set_c(par,-0.5);
2329 unur_tdr_set_usedars(par,FALSE);
2330 unur_tdr_set_cpoints(par,10,NULL);
2331 gen = unur_init(par);
2332 rcode = run_validate_chi2(TESTLOG,0,gen,distr[15],'+');
2333 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
2334 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
2335 unur_free(gen);
2336 unur_distr_free(distr_localcopy);
2337 } while (0);
2338 }
2339
2340 if(fullcheck) {
2341 unur_reset_errno();
2342 do {
2343 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[15]);
2344 par = unur_tdr_new(distr_localcopy);
2345 unur_tdr_set_variant_ia(par);
2346 unur_tdr_set_c(par,-0.5);
2347 unur_tdr_set_usedars(par,FALSE);
2348 unur_tdr_set_cpoints(par,10,NULL);
2349 unur_tdr_set_max_sqhratio(par,0.25);
2350 gen = unur_init(par);
2351 rcode = run_validate_chi2(TESTLOG,0,gen,distr[15],'+');
2352 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
2353 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
2354 unur_free(gen);
2355 unur_distr_free(distr_localcopy);
2356 } while (0);
2357 }
2358
2359 if(fullcheck) {
2360 unur_reset_errno();
2361 do {
2362 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[15]);
2363 par = unur_tdr_new(distr_localcopy);
2364 unur_tdr_set_variant_ia(par);
2365 unur_tdr_set_c(par,0.);
2366 gen = unur_init(par);
2367 rcode = run_validate_chi2(TESTLOG,0,gen,distr[15],'+');
2368 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
2369 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
2370 unur_free(gen);
2371 unur_distr_free(distr_localcopy);
2372 } while (0);
2373 }
2374
2375 if(fullcheck) {
2376 printf("."); fflush(stdout);
2377 }
2378
2379 if(fullcheck) {
2380 printf("."); fflush(stdout);
2381 }
2382
2383 /* distribution [16] */
2384
2385 if(fullcheck) {
2386 unur_reset_errno();
2387 do {
2388 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[16]);
2389 par = unur_tdr_new(distr_localcopy);
2390 unur_tdr_set_variant_ia(par);
2391 unur_tdr_set_c(par,-0.5);
2392 gen = unur_init(par);
2393 rcode = run_validate_chi2(TESTLOG,0,gen,distr[16],'+');
2394 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
2395 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
2396 unur_free(gen);
2397 unur_distr_free(distr_localcopy);
2398 } while (0);
2399 }
2400
2401 if(fullcheck) {
2402 unur_reset_errno();
2403 do {
2404 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[16]);
2405 par = unur_tdr_new(distr_localcopy);
2406 unur_tdr_set_variant_ia(par);
2407 unur_tdr_set_c(par,-0.5);
2408 unur_tdr_set_usedars(par,FALSE);
2409 unur_tdr_set_cpoints(par,10,NULL);
2410 gen = unur_init(par);
2411 rcode = run_validate_chi2(TESTLOG,0,gen,distr[16],'+');
2412 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
2413 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
2414 unur_free(gen);
2415 unur_distr_free(distr_localcopy);
2416 } while (0);
2417 }
2418
2419 if(fullcheck) {
2420 unur_reset_errno();
2421 do {
2422 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[16]);
2423 par = unur_tdr_new(distr_localcopy);
2424 unur_tdr_set_variant_ia(par);
2425 unur_tdr_set_c(par,-0.5);
2426 unur_tdr_set_usedars(par,FALSE);
2427 unur_tdr_set_cpoints(par,10,NULL);
2428 unur_tdr_set_max_sqhratio(par,0.25);
2429 gen = unur_init(par);
2430 rcode = run_validate_chi2(TESTLOG,0,gen,distr[16],'+');
2431 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
2432 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
2433 unur_free(gen);
2434 unur_distr_free(distr_localcopy);
2435 } while (0);
2436 }
2437
2438 if(fullcheck) {
2439 unur_reset_errno();
2440 do {
2441 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[16]);
2442 par = unur_tdr_new(distr_localcopy);
2443 unur_tdr_set_variant_ia(par);
2444 unur_tdr_set_c(par,0.);
2445 gen = unur_init(par);
2446 rcode = run_validate_chi2(TESTLOG,0,gen,distr[16],'+');
2447 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
2448 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
2449 unur_free(gen);
2450 unur_distr_free(distr_localcopy);
2451 } while (0);
2452 }
2453
2454 if(fullcheck) {
2455 printf("."); fflush(stdout);
2456 }
2457
2458 if(fullcheck) {
2459 printf("."); fflush(stdout);
2460 }
2461
2462 /* distribution [26] */
2463
2464 if(TRUE) {
2465 unur_reset_errno();
2466 do {
2467 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[26]);
2468 par = unur_tdr_new(distr_localcopy);
2469 unur_tdr_set_variant_ia(par);
2470 unur_tdr_set_c(par,-0.5);
2471 gen = unur_init(par);
2472 rcode = run_validate_chi2(TESTLOG,0,gen,distr[26],'+');
2473 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
2474 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
2475 unur_free(gen);
2476 unur_distr_free(distr_localcopy);
2477 } while (0);
2478 }
2479
2480 if(TRUE) {
2481 unur_reset_errno();
2482 do {
2483 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[26]);
2484 par = unur_tdr_new(distr_localcopy);
2485 unur_tdr_set_variant_ia(par);
2486 unur_tdr_set_c(par,-0.5);
2487 unur_tdr_set_usedars(par,FALSE);
2488 unur_tdr_set_cpoints(par,10,NULL);
2489 gen = unur_init(par);
2490 rcode = run_validate_chi2(TESTLOG,0,gen,distr[26],'+');
2491 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
2492 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
2493 unur_free(gen);
2494 unur_distr_free(distr_localcopy);
2495 } while (0);
2496 }
2497
2498 if(TRUE) {
2499 unur_reset_errno();
2500 do {
2501 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[26]);
2502 par = unur_tdr_new(distr_localcopy);
2503 unur_tdr_set_variant_ia(par);
2504 unur_tdr_set_c(par,-0.5);
2505 unur_tdr_set_usedars(par,FALSE);
2506 unur_tdr_set_cpoints(par,10,NULL);
2507 unur_tdr_set_max_sqhratio(par,0.25);
2508 gen = unur_init(par);
2509 rcode = run_validate_chi2(TESTLOG,0,gen,distr[26],'+');
2510 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
2511 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
2512 unur_free(gen);
2513 unur_distr_free(distr_localcopy);
2514 } while (0);
2515 }
2516
2517 if(TRUE) {
2518 unur_reset_errno();
2519 do {
2520 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[26]);
2521 par = unur_tdr_new(distr_localcopy);
2522 unur_tdr_set_variant_ia(par);
2523 unur_tdr_set_c(par,0.);
2524 gen = unur_init(par);
2525 rcode = run_validate_chi2(TESTLOG,0,gen,distr[26],'+');
2526 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
2527 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
2528 unur_free(gen);
2529 unur_distr_free(distr_localcopy);
2530 } while (0);
2531 }
2532
2533 if(TRUE) {
2534 unur_reset_errno();
2535 do {
2536 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[26]);
2537 par = unur_tdr_new(distr_localcopy);
2538 unur_tdr_set_variant_ia(par);
2539 unur_tdr_set_c(par,-0.5);
2540 unur_tdr_set_cpoints(par,30,NULL);
2541 unur_set_use_distr_privatecopy(par,FALSE);
2542 fpm[0] = 1.;
2543 fpm[1] = 4.;
2544 unur_distr_cont_set_pdfparams(distr_localcopy,fpm,2);
2545 gen = unur_init(par);
2546 if (gen) {
2547 unur_tdr_chg_reinit_percentiles(gen, 2, NULL );
2548 unur_reinit(gen);
2549 }
2550 rcode = run_validate_chi2(TESTLOG,0,gen,distr[26],'+');
2551 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
2552 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
2553 unur_free(gen);
2554 unur_distr_free(distr_localcopy);
2555 } while (0);
2556 }
2557
2558 if(TRUE) {
2559 unur_reset_errno();
2560 do {
2561 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[26]);
2562 par = unur_tdr_new(distr_localcopy);
2563 unur_tdr_set_variant_ia(par);
2564 unur_tdr_set_c(par,0.);
2565 unur_tdr_set_cpoints(par,30,NULL);
2566 unur_set_use_distr_privatecopy(par,FALSE);
2567 fpm[0] = 1.;
2568 fpm[1] = 4.;
2569 unur_distr_cont_set_pdfparams(distr_localcopy,fpm,2);
2570 gen = unur_init(par);
2571 if (gen) {
2572 unur_tdr_chg_reinit_percentiles(gen, 2, NULL );
2573 unur_reinit(gen);
2574 }
2575 rcode = run_validate_chi2(TESTLOG,0,gen,distr[26],'+');
2576 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
2577 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
2578 unur_free(gen);
2579 unur_distr_free(distr_localcopy);
2580 } while (0);
2581 }
2582
2583 /* distribution [27] */
2584
2585 if(TRUE) {
2586 unur_reset_errno();
2587 do {
2588 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[27]);
2589 par = unur_tdr_new(distr_localcopy);
2590 unur_tdr_set_variant_ia(par);
2591 unur_tdr_set_c(par,-0.5);
2592 gen = unur_init(par);
2593 rcode = run_validate_chi2(TESTLOG,0,gen,distr[27],'+');
2594 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
2595 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
2596 unur_free(gen);
2597 unur_distr_free(distr_localcopy);
2598 } while (0);
2599 }
2600
2601 if(TRUE) {
2602 unur_reset_errno();
2603 do {
2604 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[27]);
2605 par = unur_tdr_new(distr_localcopy);
2606 unur_tdr_set_variant_ia(par);
2607 unur_tdr_set_c(par,-0.5);
2608 unur_tdr_set_usedars(par,FALSE);
2609 unur_tdr_set_cpoints(par,10,NULL);
2610 gen = unur_init(par);
2611 rcode = run_validate_chi2(TESTLOG,0,gen,distr[27],'+');
2612 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
2613 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
2614 unur_free(gen);
2615 unur_distr_free(distr_localcopy);
2616 } while (0);
2617 }
2618
2619 if(TRUE) {
2620 unur_reset_errno();
2621 do {
2622 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[27]);
2623 par = unur_tdr_new(distr_localcopy);
2624 unur_tdr_set_variant_ia(par);
2625 unur_tdr_set_c(par,-0.5);
2626 unur_tdr_set_usedars(par,FALSE);
2627 unur_tdr_set_cpoints(par,10,NULL);
2628 unur_tdr_set_max_sqhratio(par,0.25);
2629 gen = unur_init(par);
2630 rcode = run_validate_chi2(TESTLOG,0,gen,distr[27],'+');
2631 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
2632 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
2633 unur_free(gen);
2634 unur_distr_free(distr_localcopy);
2635 } while (0);
2636 }
2637
2638 if(TRUE) {
2639 unur_reset_errno();
2640 do {
2641 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[27]);
2642 par = unur_tdr_new(distr_localcopy);
2643 unur_tdr_set_variant_ia(par);
2644 unur_tdr_set_c(par,0.);
2645 gen = unur_init(par);
2646 rcode = run_validate_chi2(TESTLOG,0,gen,distr[27],'+');
2647 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
2648 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
2649 unur_free(gen);
2650 unur_distr_free(distr_localcopy);
2651 } while (0);
2652 }
2653
2654 if(TRUE) {
2655 unur_reset_errno();
2656 do {
2657 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[27]);
2658 par = unur_tdr_new(distr_localcopy);
2659 unur_tdr_set_variant_ia(par);
2660 unur_tdr_set_c(par,-0.5);
2661 unur_tdr_set_cpoints(par,30,NULL);
2662 unur_set_use_distr_privatecopy(par,FALSE);
2663 fpm[0] = 1.;
2664 fpm[1] = 4.;
2665 unur_distr_cont_set_pdfparams(distr_localcopy,fpm,2);
2666 gen = unur_init(par);
2667 if (gen) {
2668 unur_tdr_chg_reinit_percentiles(gen, 2, NULL );
2669 unur_reinit(gen);
2670 }
2671 rcode = run_validate_chi2(TESTLOG,0,gen,distr[27],'+');
2672 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
2673 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
2674 unur_free(gen);
2675 unur_distr_free(distr_localcopy);
2676 } while (0);
2677 }
2678
2679 if(TRUE) {
2680 unur_reset_errno();
2681 do {
2682 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[27]);
2683 par = unur_tdr_new(distr_localcopy);
2684 unur_tdr_set_variant_ia(par);
2685 unur_tdr_set_c(par,0.);
2686 unur_tdr_set_cpoints(par,30,NULL);
2687 unur_set_use_distr_privatecopy(par,FALSE);
2688 fpm[0] = 1.;
2689 fpm[1] = 4.;
2690 unur_distr_cont_set_pdfparams(distr_localcopy,fpm,2);
2691 gen = unur_init(par);
2692 if (gen) {
2693 unur_tdr_chg_reinit_percentiles(gen, 2, NULL );
2694 unur_reinit(gen);
2695 }
2696 rcode = run_validate_chi2(TESTLOG,0,gen,distr[27],'+');
2697 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
2698 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
2699 unur_free(gen);
2700 unur_distr_free(distr_localcopy);
2701 } while (0);
2702 }
2703
2704 /* distribution [17] */
2705
2706 if(TRUE) {
2707 unur_reset_errno();
2708 do {
2709 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[17]);
2710 par = unur_tdr_new(distr_localcopy);
2711 unur_tdr_set_variant_ia(par);
2712 unur_tdr_set_c(par,-0.5);
2713 gen = unur_init(par);
2714 rcode = run_validate_chi2(TESTLOG,0,gen,distr[17],'+');
2715 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
2716 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
2717 unur_free(gen);
2718 unur_distr_free(distr_localcopy);
2719 } while (0);
2720 }
2721
2722 if(TRUE) {
2723 unur_reset_errno();
2724 do {
2725 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[17]);
2726 par = unur_tdr_new(distr_localcopy);
2727 unur_tdr_set_variant_ia(par);
2728 unur_tdr_set_c(par,-0.5);
2729 unur_tdr_set_usedars(par,FALSE);
2730 unur_tdr_set_cpoints(par,10,NULL);
2731 gen = unur_init(par);
2732 rcode = run_validate_chi2(TESTLOG,0,gen,distr[17],'+');
2733 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
2734 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
2735 unur_free(gen);
2736 unur_distr_free(distr_localcopy);
2737 } while (0);
2738 }
2739
2740 if(TRUE) {
2741 unur_reset_errno();
2742 do {
2743 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[17]);
2744 par = unur_tdr_new(distr_localcopy);
2745 unur_tdr_set_variant_ia(par);
2746 unur_tdr_set_c(par,-0.5);
2747 unur_tdr_set_usedars(par,FALSE);
2748 unur_tdr_set_cpoints(par,10,NULL);
2749 unur_tdr_set_max_sqhratio(par,0.25);
2750 gen = unur_init(par);
2751 rcode = run_validate_chi2(TESTLOG,0,gen,distr[17],'+');
2752 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
2753 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
2754 unur_free(gen);
2755 unur_distr_free(distr_localcopy);
2756 } while (0);
2757 }
2758
2759 if(TRUE) {
2760 unur_reset_errno();
2761 do {
2762 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[17]);
2763 par = unur_tdr_new(distr_localcopy);
2764 unur_tdr_set_variant_ia(par);
2765 unur_tdr_set_c(par,0.);
2766 gen = unur_init(par);
2767 rcode = run_validate_chi2(TESTLOG,0,gen,distr[17],'+');
2768 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
2769 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
2770 unur_free(gen);
2771 unur_distr_free(distr_localcopy);
2772 } while (0);
2773 }
2774
2775 if(TRUE) {
2776 unur_reset_errno();
2777 do {
2778 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[17]);
2779 par = unur_tdr_new(distr_localcopy);
2780 unur_tdr_set_variant_ia(par);
2781 unur_tdr_set_c(par,-0.5);
2782 unur_tdr_set_cpoints(par,30,NULL);
2783 unur_set_use_distr_privatecopy(par,FALSE);
2784 fpm[0] = 1.;
2785 fpm[1] = 4.;
2786 unur_distr_cont_set_pdfparams(distr_localcopy,fpm,2);
2787 gen = unur_init(par);
2788 if (gen) {
2789 unur_tdr_chg_reinit_percentiles(gen, 2, NULL );
2790 unur_reinit(gen);
2791 }
2792 rcode = run_validate_chi2(TESTLOG,0,gen,distr[17],'+');
2793 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
2794 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
2795 unur_free(gen);
2796 unur_distr_free(distr_localcopy);
2797 } while (0);
2798 }
2799
2800 if(TRUE) {
2801 unur_reset_errno();
2802 do {
2803 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[17]);
2804 par = unur_tdr_new(distr_localcopy);
2805 unur_tdr_set_variant_ia(par);
2806 unur_tdr_set_c(par,0.);
2807 unur_tdr_set_cpoints(par,30,NULL);
2808 unur_set_use_distr_privatecopy(par,FALSE);
2809 fpm[0] = 1.;
2810 fpm[1] = 4.;
2811 unur_distr_cont_set_pdfparams(distr_localcopy,fpm,2);
2812 gen = unur_init(par);
2813 if (gen) {
2814 unur_tdr_chg_reinit_percentiles(gen, 2, NULL );
2815 unur_reinit(gen);
2816 }
2817 rcode = run_validate_chi2(TESTLOG,0,gen,distr[17],'+');
2818 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
2819 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
2820 unur_free(gen);
2821 unur_distr_free(distr_localcopy);
2822 } while (0);
2823 }
2824
2825 /* distribution [18] */
2826
2827 if(fullcheck) {
2828 unur_reset_errno();
2829 do {
2830 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[18]);
2831 par = unur_tdr_new(distr_localcopy);
2832 unur_tdr_set_variant_ia(par);
2833 unur_tdr_set_c(par,-0.5);
2834 gen = unur_init(par);
2835 rcode = run_validate_chi2(TESTLOG,0,gen,distr[18],'+');
2836 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
2837 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
2838 unur_free(gen);
2839 unur_distr_free(distr_localcopy);
2840 } while (0);
2841 }
2842
2843 if(fullcheck) {
2844 unur_reset_errno();
2845 do {
2846 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[18]);
2847 par = unur_tdr_new(distr_localcopy);
2848 unur_tdr_set_variant_ia(par);
2849 unur_tdr_set_c(par,-0.5);
2850 unur_tdr_set_usedars(par,FALSE);
2851 unur_tdr_set_cpoints(par,10,NULL);
2852 gen = unur_init(par);
2853 rcode = run_validate_chi2(TESTLOG,0,gen,distr[18],'+');
2854 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
2855 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
2856 unur_free(gen);
2857 unur_distr_free(distr_localcopy);
2858 } while (0);
2859 }
2860
2861 if(fullcheck) {
2862 unur_reset_errno();
2863 do {
2864 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[18]);
2865 par = unur_tdr_new(distr_localcopy);
2866 unur_tdr_set_variant_ia(par);
2867 unur_tdr_set_c(par,-0.5);
2868 unur_tdr_set_usedars(par,FALSE);
2869 unur_tdr_set_cpoints(par,10,NULL);
2870 unur_tdr_set_max_sqhratio(par,0.25);
2871 gen = unur_init(par);
2872 rcode = run_validate_chi2(TESTLOG,0,gen,distr[18],'+');
2873 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
2874 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
2875 unur_free(gen);
2876 unur_distr_free(distr_localcopy);
2877 } while (0);
2878 }
2879
2880 if(fullcheck) {
2881 unur_reset_errno();
2882 do {
2883 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[18]);
2884 par = unur_tdr_new(distr_localcopy);
2885 unur_tdr_set_variant_ia(par);
2886 unur_tdr_set_c(par,0.);
2887 gen = unur_init(par);
2888 rcode = run_validate_chi2(TESTLOG,0,gen,distr[18],'+');
2889 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
2890 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
2891 unur_free(gen);
2892 unur_distr_free(distr_localcopy);
2893 } while (0);
2894 }
2895
2896 if(fullcheck) {
2897 unur_reset_errno();
2898 do {
2899 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[18]);
2900 par = unur_tdr_new(distr_localcopy);
2901 unur_tdr_set_variant_ia(par);
2902 unur_tdr_set_c(par,-0.5);
2903 unur_tdr_set_cpoints(par,30,NULL);
2904 unur_set_use_distr_privatecopy(par,FALSE);
2905 fpm[0] = 1.;
2906 fpm[1] = 4.;
2907 unur_distr_cont_set_pdfparams(distr_localcopy,fpm,2);
2908 gen = unur_init(par);
2909 if (gen) {
2910 unur_tdr_chg_reinit_percentiles(gen, 2, NULL );
2911 unur_reinit(gen);
2912 }
2913 rcode = run_validate_chi2(TESTLOG,0,gen,distr[18],'+');
2914 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
2915 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
2916 unur_free(gen);
2917 unur_distr_free(distr_localcopy);
2918 } while (0);
2919 }
2920
2921 if(fullcheck) {
2922 unur_reset_errno();
2923 do {
2924 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[18]);
2925 par = unur_tdr_new(distr_localcopy);
2926 unur_tdr_set_variant_ia(par);
2927 unur_tdr_set_c(par,0.);
2928 unur_tdr_set_cpoints(par,30,NULL);
2929 unur_set_use_distr_privatecopy(par,FALSE);
2930 fpm[0] = 1.;
2931 fpm[1] = 4.;
2932 unur_distr_cont_set_pdfparams(distr_localcopy,fpm,2);
2933 gen = unur_init(par);
2934 if (gen) {
2935 unur_tdr_chg_reinit_percentiles(gen, 2, NULL );
2936 unur_reinit(gen);
2937 }
2938 rcode = run_validate_chi2(TESTLOG,0,gen,distr[18],'+');
2939 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
2940 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
2941 unur_free(gen);
2942 unur_distr_free(distr_localcopy);
2943 } while (0);
2944 }
2945
2946 /* distribution [19] */
2947
2948 if(TRUE) {
2949 unur_reset_errno();
2950 do {
2951 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[19]);
2952 par = unur_tdr_new(distr_localcopy);
2953 unur_tdr_set_variant_ia(par);
2954 unur_tdr_set_c(par,-0.5);
2955 gen = unur_init(par);
2956 rcode = run_validate_chi2(TESTLOG,0,gen,distr[19],'+');
2957 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
2958 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
2959 unur_free(gen);
2960 unur_distr_free(distr_localcopy);
2961 } while (0);
2962 }
2963
2964 if(TRUE) {
2965 unur_reset_errno();
2966 do {
2967 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[19]);
2968 par = unur_tdr_new(distr_localcopy);
2969 unur_tdr_set_variant_ia(par);
2970 unur_tdr_set_c(par,-0.5);
2971 unur_tdr_set_usedars(par,FALSE);
2972 unur_tdr_set_cpoints(par,10,NULL);
2973 gen = unur_init(par);
2974 rcode = run_validate_chi2(TESTLOG,0,gen,distr[19],'+');
2975 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
2976 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
2977 unur_free(gen);
2978 unur_distr_free(distr_localcopy);
2979 } while (0);
2980 }
2981
2982 if(TRUE) {
2983 unur_reset_errno();
2984 do {
2985 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[19]);
2986 par = unur_tdr_new(distr_localcopy);
2987 unur_tdr_set_variant_ia(par);
2988 unur_tdr_set_c(par,-0.5);
2989 unur_tdr_set_usedars(par,FALSE);
2990 unur_tdr_set_cpoints(par,10,NULL);
2991 unur_tdr_set_max_sqhratio(par,0.25);
2992 gen = unur_init(par);
2993 rcode = run_validate_chi2(TESTLOG,0,gen,distr[19],'+');
2994 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
2995 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
2996 unur_free(gen);
2997 unur_distr_free(distr_localcopy);
2998 } while (0);
2999 }
3000
3001 if(TRUE) {
3002 unur_reset_errno();
3003 do {
3004 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[19]);
3005 par = unur_tdr_new(distr_localcopy);
3006 unur_tdr_set_variant_ia(par);
3007 unur_tdr_set_c(par,0.);
3008 gen = unur_init(par);
3009 rcode = run_validate_chi2(TESTLOG,0,gen,distr[19],'+');
3010 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
3011 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
3012 unur_free(gen);
3013 unur_distr_free(distr_localcopy);
3014 } while (0);
3015 }
3016
3017 if(TRUE) {
3018 unur_reset_errno();
3019 do {
3020 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[19]);
3021 par = unur_tdr_new(distr_localcopy);
3022 unur_tdr_set_variant_ia(par);
3023 unur_tdr_set_c(par,-0.5);
3024 unur_tdr_set_cpoints(par,30,NULL);
3025 unur_set_use_distr_privatecopy(par,FALSE);
3026 fpm[0] = 1.;
3027 fpm[1] = 4.;
3028 unur_distr_cont_set_pdfparams(distr_localcopy,fpm,2);
3029 gen = unur_init(par);
3030 if (gen) {
3031 unur_tdr_chg_reinit_percentiles(gen, 2, NULL );
3032 unur_reinit(gen);
3033 }
3034 rcode = run_validate_chi2(TESTLOG,0,gen,distr[19],'+');
3035 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
3036 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
3037 unur_free(gen);
3038 unur_distr_free(distr_localcopy);
3039 } while (0);
3040 }
3041
3042 if(TRUE) {
3043 unur_reset_errno();
3044 do {
3045 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[19]);
3046 par = unur_tdr_new(distr_localcopy);
3047 unur_tdr_set_variant_ia(par);
3048 unur_tdr_set_c(par,0.);
3049 unur_tdr_set_cpoints(par,30,NULL);
3050 unur_set_use_distr_privatecopy(par,FALSE);
3051 fpm[0] = 1.;
3052 fpm[1] = 4.;
3053 unur_distr_cont_set_pdfparams(distr_localcopy,fpm,2);
3054 gen = unur_init(par);
3055 if (gen) {
3056 unur_tdr_chg_reinit_percentiles(gen, 2, NULL );
3057 unur_reinit(gen);
3058 }
3059 rcode = run_validate_chi2(TESTLOG,0,gen,distr[19],'+');
3060 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
3061 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
3062 unur_free(gen);
3063 unur_distr_free(distr_localcopy);
3064 } while (0);
3065 }
3066
3067 /* distribution [20] */
3068
3069 if(TRUE) {
3070 unur_reset_errno();
3071 do {
3072 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[20]);
3073 par = unur_tdr_new(distr_localcopy);
3074 unur_tdr_set_variant_ia(par);
3075 unur_tdr_set_c(par,-0.5);
3076 gen = unur_init(par);
3077 rcode = run_validate_chi2(TESTLOG,0,gen,distr[20],'+');
3078 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
3079 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
3080 unur_free(gen);
3081 unur_distr_free(distr_localcopy);
3082 } while (0);
3083 }
3084
3085 if(TRUE) {
3086 unur_reset_errno();
3087 do {
3088 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[20]);
3089 par = unur_tdr_new(distr_localcopy);
3090 unur_tdr_set_variant_ia(par);
3091 unur_tdr_set_c(par,-0.5);
3092 unur_tdr_set_usedars(par,FALSE);
3093 unur_tdr_set_cpoints(par,10,NULL);
3094 gen = unur_init(par);
3095 rcode = run_validate_chi2(TESTLOG,0,gen,distr[20],'+');
3096 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
3097 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
3098 unur_free(gen);
3099 unur_distr_free(distr_localcopy);
3100 } while (0);
3101 }
3102
3103 if(TRUE) {
3104 unur_reset_errno();
3105 do {
3106 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[20]);
3107 par = unur_tdr_new(distr_localcopy);
3108 unur_tdr_set_variant_ia(par);
3109 unur_tdr_set_c(par,-0.5);
3110 unur_tdr_set_usedars(par,FALSE);
3111 unur_tdr_set_cpoints(par,10,NULL);
3112 unur_tdr_set_max_sqhratio(par,0.25);
3113 gen = unur_init(par);
3114 rcode = run_validate_chi2(TESTLOG,0,gen,distr[20],'+');
3115 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
3116 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
3117 unur_free(gen);
3118 unur_distr_free(distr_localcopy);
3119 } while (0);
3120 }
3121
3122 if(TRUE) {
3123 unur_reset_errno();
3124 do {
3125 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[20]);
3126 par = unur_tdr_new(distr_localcopy);
3127 unur_tdr_set_variant_ia(par);
3128 unur_tdr_set_c(par,0.);
3129 gen = unur_init(par);
3130 rcode = run_validate_chi2(TESTLOG,0,gen,distr[20],'+');
3131 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
3132 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
3133 unur_free(gen);
3134 unur_distr_free(distr_localcopy);
3135 } while (0);
3136 }
3137
3138 if(TRUE) {
3139 unur_reset_errno();
3140 do {
3141 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[20]);
3142 par = unur_tdr_new(distr_localcopy);
3143 unur_tdr_set_variant_ia(par);
3144 unur_tdr_set_c(par,-0.5);
3145 unur_tdr_set_cpoints(par,30,NULL);
3146 unur_set_use_distr_privatecopy(par,FALSE);
3147 fpm[0] = 1.;
3148 fpm[1] = 4.;
3149 unur_distr_cont_set_pdfparams(distr_localcopy,fpm,2);
3150 gen = unur_init(par);
3151 if (gen) {
3152 unur_tdr_chg_reinit_percentiles(gen, 2, NULL );
3153 unur_reinit(gen);
3154 }
3155 rcode = run_validate_chi2(TESTLOG,0,gen,distr[20],'+');
3156 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
3157 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
3158 unur_free(gen);
3159 unur_distr_free(distr_localcopy);
3160 } while (0);
3161 }
3162
3163 if(TRUE) {
3164 unur_reset_errno();
3165 do {
3166 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[20]);
3167 par = unur_tdr_new(distr_localcopy);
3168 unur_tdr_set_variant_ia(par);
3169 unur_tdr_set_c(par,0.);
3170 unur_tdr_set_cpoints(par,30,NULL);
3171 unur_set_use_distr_privatecopy(par,FALSE);
3172 fpm[0] = 1.;
3173 fpm[1] = 4.;
3174 unur_distr_cont_set_pdfparams(distr_localcopy,fpm,2);
3175 gen = unur_init(par);
3176 if (gen) {
3177 unur_tdr_chg_reinit_percentiles(gen, 2, NULL );
3178 unur_reinit(gen);
3179 }
3180 rcode = run_validate_chi2(TESTLOG,0,gen,distr[20],'+');
3181 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
3182 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
3183 unur_free(gen);
3184 unur_distr_free(distr_localcopy);
3185 } while (0);
3186 }
3187
3188 /* distribution [21] */
3189
3190 if(TRUE) {
3191 unur_reset_errno();
3192 do {
3193 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[21]);
3194 par = unur_tdr_new(distr_localcopy);
3195 unur_tdr_set_variant_ia(par);
3196 unur_tdr_set_c(par,-0.5);
3197 gen = unur_init(par);
3198 rcode = run_validate_chi2(TESTLOG,0,gen,distr[21],'+');
3199 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
3200 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
3201 unur_free(gen);
3202 unur_distr_free(distr_localcopy);
3203 } while (0);
3204 }
3205
3206 if(TRUE) {
3207 unur_reset_errno();
3208 do {
3209 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[21]);
3210 par = unur_tdr_new(distr_localcopy);
3211 unur_tdr_set_variant_ia(par);
3212 unur_tdr_set_c(par,-0.5);
3213 unur_tdr_set_usedars(par,FALSE);
3214 unur_tdr_set_cpoints(par,10,NULL);
3215 gen = unur_init(par);
3216 rcode = run_validate_chi2(TESTLOG,0,gen,distr[21],'+');
3217 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
3218 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
3219 unur_free(gen);
3220 unur_distr_free(distr_localcopy);
3221 } while (0);
3222 }
3223
3224 if(TRUE) {
3225 unur_reset_errno();
3226 do {
3227 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[21]);
3228 par = unur_tdr_new(distr_localcopy);
3229 unur_tdr_set_variant_ia(par);
3230 unur_tdr_set_c(par,-0.5);
3231 unur_tdr_set_usedars(par,FALSE);
3232 unur_tdr_set_cpoints(par,10,NULL);
3233 unur_tdr_set_max_sqhratio(par,0.25);
3234 gen = unur_init(par);
3235 rcode = run_validate_chi2(TESTLOG,0,gen,distr[21],'+');
3236 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
3237 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
3238 unur_free(gen);
3239 unur_distr_free(distr_localcopy);
3240 } while (0);
3241 }
3242
3243 if(TRUE) {
3244 unur_reset_errno();
3245 do {
3246 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[21]);
3247 par = unur_tdr_new(distr_localcopy);
3248 unur_tdr_set_variant_ia(par);
3249 unur_tdr_set_c(par,0.);
3250 gen = unur_init(par);
3251 rcode = run_validate_chi2(TESTLOG,0,gen,distr[21],'+');
3252 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
3253 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
3254 unur_free(gen);
3255 unur_distr_free(distr_localcopy);
3256 } while (0);
3257 }
3258
3259 if(TRUE) {
3260 printf("."); fflush(stdout);
3261 }
3262
3263 if(TRUE) {
3264 printf("."); fflush(stdout);
3265 }
3266
3267 /* distribution [22] */
3268
3269 if(TRUE) {
3270 unur_reset_errno();
3271 do {
3272 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[22]);
3273 par = unur_tdr_new(distr_localcopy);
3274 unur_tdr_set_variant_ia(par);
3275 unur_tdr_set_c(par,-0.5);
3276 gen = unur_init(par);
3277 rcode = run_validate_chi2(TESTLOG,0,gen,distr[22],'+');
3278 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
3279 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
3280 unur_free(gen);
3281 unur_distr_free(distr_localcopy);
3282 } while (0);
3283 }
3284
3285 if(TRUE) {
3286 unur_reset_errno();
3287 do {
3288 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[22]);
3289 par = unur_tdr_new(distr_localcopy);
3290 unur_tdr_set_variant_ia(par);
3291 unur_tdr_set_c(par,-0.5);
3292 unur_tdr_set_usedars(par,FALSE);
3293 unur_tdr_set_cpoints(par,10,NULL);
3294 gen = unur_init(par);
3295 rcode = run_validate_chi2(TESTLOG,0,gen,distr[22],'+');
3296 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
3297 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
3298 unur_free(gen);
3299 unur_distr_free(distr_localcopy);
3300 } while (0);
3301 }
3302
3303 if(TRUE) {
3304 unur_reset_errno();
3305 do {
3306 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[22]);
3307 par = unur_tdr_new(distr_localcopy);
3308 unur_tdr_set_variant_ia(par);
3309 unur_tdr_set_c(par,-0.5);
3310 unur_tdr_set_usedars(par,FALSE);
3311 unur_tdr_set_cpoints(par,10,NULL);
3312 unur_tdr_set_max_sqhratio(par,0.25);
3313 gen = unur_init(par);
3314 rcode = run_validate_chi2(TESTLOG,0,gen,distr[22],'+');
3315 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
3316 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
3317 unur_free(gen);
3318 unur_distr_free(distr_localcopy);
3319 } while (0);
3320 }
3321
3322 if(TRUE) {
3323 unur_reset_errno();
3324 do {
3325 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[22]);
3326 par = unur_tdr_new(distr_localcopy);
3327 unur_tdr_set_variant_ia(par);
3328 unur_tdr_set_c(par,0.);
3329 gen = unur_init(par);
3330 rcode = run_validate_chi2(TESTLOG,0,gen,distr[22],'+');
3331 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
3332 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
3333 unur_free(gen);
3334 unur_distr_free(distr_localcopy);
3335 } while (0);
3336 }
3337
3338 if(TRUE) {
3339 printf("."); fflush(stdout);
3340 }
3341
3342 if(TRUE) {
3343 printf("."); fflush(stdout);
3344 }
3345
3346 /* distribution [23] */
3347
3348 if(TRUE) {
3349 unur_reset_errno();
3350 do {
3351 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[23]);
3352 par = unur_tdr_new(distr_localcopy);
3353 unur_tdr_set_variant_ia(par);
3354 unur_tdr_set_c(par,-0.5);
3355 gen = unur_init(par);
3356 rcode = run_validate_chi2(TESTLOG,0,gen,distr[23],'+');
3357 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
3358 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
3359 unur_free(gen);
3360 unur_distr_free(distr_localcopy);
3361 } while (0);
3362 }
3363
3364 if(TRUE) {
3365 unur_reset_errno();
3366 do {
3367 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[23]);
3368 par = unur_tdr_new(distr_localcopy);
3369 unur_tdr_set_variant_ia(par);
3370 unur_tdr_set_c(par,-0.5);
3371 unur_tdr_set_usedars(par,FALSE);
3372 unur_tdr_set_cpoints(par,10,NULL);
3373 gen = unur_init(par);
3374 rcode = run_validate_chi2(TESTLOG,0,gen,distr[23],'+');
3375 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
3376 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
3377 unur_free(gen);
3378 unur_distr_free(distr_localcopy);
3379 } while (0);
3380 }
3381
3382 if(TRUE) {
3383 unur_reset_errno();
3384 do {
3385 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[23]);
3386 par = unur_tdr_new(distr_localcopy);
3387 unur_tdr_set_variant_ia(par);
3388 unur_tdr_set_c(par,-0.5);
3389 unur_tdr_set_usedars(par,FALSE);
3390 unur_tdr_set_cpoints(par,10,NULL);
3391 unur_tdr_set_max_sqhratio(par,0.25);
3392 gen = unur_init(par);
3393 rcode = run_validate_chi2(TESTLOG,0,gen,distr[23],'+');
3394 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
3395 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
3396 unur_free(gen);
3397 unur_distr_free(distr_localcopy);
3398 } while (0);
3399 }
3400
3401 if(TRUE) {
3402 unur_reset_errno();
3403 do {
3404 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[23]);
3405 par = unur_tdr_new(distr_localcopy);
3406 unur_tdr_set_variant_ia(par);
3407 unur_tdr_set_c(par,0.);
3408 gen = unur_init(par);
3409 rcode = run_validate_chi2(TESTLOG,0,gen,distr[23],'+');
3410 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
3411 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
3412 unur_free(gen);
3413 unur_distr_free(distr_localcopy);
3414 } while (0);
3415 }
3416
3417 if(TRUE) {
3418 printf("."); fflush(stdout);
3419 }
3420
3421 if(TRUE) {
3422 printf("."); fflush(stdout);
3423 }
3424
3425 /* distribution [28] */
3426
3427 if(TRUE) {
3428 unur_reset_errno();
3429 do {
3430 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[28]);
3431 par = unur_tdr_new(distr_localcopy);
3432 unur_tdr_set_variant_ia(par);
3433 unur_tdr_set_c(par,-0.5);
3434 gen = unur_init(par);
3435 rcode = run_validate_chi2(TESTLOG,0,gen,distr[28],'+');
3436 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
3437 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
3438 unur_free(gen);
3439 unur_distr_free(distr_localcopy);
3440 } while (0);
3441 }
3442
3443 if(TRUE) {
3444 unur_reset_errno();
3445 do {
3446 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[28]);
3447 par = unur_tdr_new(distr_localcopy);
3448 unur_tdr_set_variant_ia(par);
3449 unur_tdr_set_c(par,-0.5);
3450 unur_tdr_set_usedars(par,FALSE);
3451 unur_tdr_set_cpoints(par,10,NULL);
3452 gen = unur_init(par);
3453 rcode = run_validate_chi2(TESTLOG,0,gen,distr[28],'+');
3454 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
3455 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
3456 unur_free(gen);
3457 unur_distr_free(distr_localcopy);
3458 } while (0);
3459 }
3460
3461 if(TRUE) {
3462 unur_reset_errno();
3463 do {
3464 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[28]);
3465 par = unur_tdr_new(distr_localcopy);
3466 unur_tdr_set_variant_ia(par);
3467 unur_tdr_set_c(par,-0.5);
3468 unur_tdr_set_usedars(par,FALSE);
3469 unur_tdr_set_cpoints(par,10,NULL);
3470 unur_tdr_set_max_sqhratio(par,0.25);
3471 gen = unur_init(par);
3472 rcode = run_validate_chi2(TESTLOG,0,gen,distr[28],'+');
3473 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
3474 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
3475 unur_free(gen);
3476 unur_distr_free(distr_localcopy);
3477 } while (0);
3478 }
3479
3480 if(TRUE) {
3481 unur_reset_errno();
3482 do {
3483 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[28]);
3484 par = unur_tdr_new(distr_localcopy);
3485 unur_tdr_set_variant_ia(par);
3486 unur_tdr_set_c(par,0.);
3487 gen = unur_init(par);
3488 rcode = run_validate_chi2(TESTLOG,0,gen,distr[28],'0');
3489 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
3490 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
3491 unur_free(gen);
3492 unur_distr_free(distr_localcopy);
3493 } while (0);
3494 }
3495
3496 if(TRUE) {
3497 printf("."); fflush(stdout);
3498 }
3499
3500 if(TRUE) {
3501 printf("."); fflush(stdout);
3502 }
3503
3504 /* distribution [29] */
3505
3506 if(TRUE) {
3507 unur_reset_errno();
3508 do {
3509 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[29]);
3510 par = unur_tdr_new(distr_localcopy);
3511 unur_tdr_set_variant_ia(par);
3512 unur_tdr_set_c(par,-0.5);
3513 gen = unur_init(par);
3514 rcode = run_validate_chi2(TESTLOG,0,gen,distr[29],'+');
3515 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
3516 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
3517 unur_free(gen);
3518 unur_distr_free(distr_localcopy);
3519 } while (0);
3520 }
3521
3522 if(TRUE) {
3523 unur_reset_errno();
3524 do {
3525 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[29]);
3526 par = unur_tdr_new(distr_localcopy);
3527 unur_tdr_set_variant_ia(par);
3528 unur_tdr_set_c(par,-0.5);
3529 unur_tdr_set_usedars(par,FALSE);
3530 unur_tdr_set_cpoints(par,10,NULL);
3531 gen = unur_init(par);
3532 rcode = run_validate_chi2(TESTLOG,0,gen,distr[29],'+');
3533 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
3534 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
3535 unur_free(gen);
3536 unur_distr_free(distr_localcopy);
3537 } while (0);
3538 }
3539
3540 if(TRUE) {
3541 unur_reset_errno();
3542 do {
3543 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[29]);
3544 par = unur_tdr_new(distr_localcopy);
3545 unur_tdr_set_variant_ia(par);
3546 unur_tdr_set_c(par,-0.5);
3547 unur_tdr_set_usedars(par,FALSE);
3548 unur_tdr_set_cpoints(par,10,NULL);
3549 unur_tdr_set_max_sqhratio(par,0.25);
3550 gen = unur_init(par);
3551 rcode = run_validate_chi2(TESTLOG,0,gen,distr[29],'+');
3552 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
3553 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
3554 unur_free(gen);
3555 unur_distr_free(distr_localcopy);
3556 } while (0);
3557 }
3558
3559 if(TRUE) {
3560 unur_reset_errno();
3561 do {
3562 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[29]);
3563 par = unur_tdr_new(distr_localcopy);
3564 unur_tdr_set_variant_ia(par);
3565 unur_tdr_set_c(par,0.);
3566 gen = unur_init(par);
3567 rcode = run_validate_chi2(TESTLOG,0,gen,distr[29],'0');
3568 n_tests_failed += (rcode==UNUR_SUCCESS)?0:1;
3569 n_tests_failed += (rcode==UNUR_FAILURE)?1000:0;
3570 unur_free(gen);
3571 unur_distr_free(distr_localcopy);
3572 } while (0);
3573 }
3574
3575 if(TRUE) {
3576 printf("."); fflush(stdout);
3577 }
3578
3579 if(TRUE) {
3580 printf("."); fflush(stdout);
3581 }
3582
3583 /* timing */
3584 stopwatch_print(TESTLOG,"\n<*>time = %.0f ms\n", stopwatch_lap(&watch));
3585
3586 printf("\n(verify hat) "); fflush(stdout);
3587
3588 /* verify hat tests: 192 */
3589
3590 unur_set_default_debug(~UNUR_DEBUG_SAMPLE);
3591 fprintf( TESTLOG,"\nVerify Hat Test (squeeze <= PDF <= hat):\n");
3592
3593 /* distribution [0] */
3594
3595 if(fullcheck) {
3596 unur_reset_errno();
3597 do {
3598 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[0]);
3599 par = unur_tdr_new(distr_localcopy);
3600 unur_tdr_set_pedantic(par,0);
3601 unur_tdr_set_variant_ia(par);
3602 unur_tdr_set_c(par,-0.5);
3603 gen = unur_init(par);
3604 if (gen) unur_tdr_chg_verify(gen,1);
3605 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[0],'~')==UNUR_SUCCESS)?0:1000;
3606 unur_free(gen);
3607
3608 unur_distr_free(distr_localcopy);
3609 } while (0);
3610 }
3611
3612 if(fullcheck) {
3613 unur_reset_errno();
3614 do {
3615 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[0]);
3616 par = unur_tdr_new(distr_localcopy);
3617 unur_tdr_set_pedantic(par,0);
3618 unur_tdr_set_variant_ia(par);
3619 unur_tdr_set_c(par,-0.5);
3620 unur_tdr_set_usedars(par,FALSE);
3621 unur_tdr_set_cpoints(par,10,NULL);
3622 gen = unur_init(par);
3623 if (gen) unur_tdr_chg_verify(gen,1);
3624 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[0],'~')==UNUR_SUCCESS)?0:1000;
3625 unur_free(gen);
3626
3627 unur_distr_free(distr_localcopy);
3628 } while (0);
3629 }
3630
3631 if(fullcheck) {
3632 unur_reset_errno();
3633 do {
3634 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[0]);
3635 par = unur_tdr_new(distr_localcopy);
3636 unur_tdr_set_pedantic(par,0);
3637 unur_tdr_set_variant_ia(par);
3638 unur_tdr_set_c(par,-0.5);
3639 unur_tdr_set_usedars(par,FALSE);
3640 unur_tdr_set_cpoints(par,10,NULL);
3641 unur_tdr_set_max_sqhratio(par,0.25);
3642 gen = unur_init(par);
3643 if (gen) unur_tdr_chg_verify(gen,1);
3644 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[0],'~')==UNUR_SUCCESS)?0:1000;
3645 unur_free(gen);
3646
3647 unur_distr_free(distr_localcopy);
3648 } while (0);
3649 }
3650
3651 if(fullcheck) {
3652 unur_reset_errno();
3653 do {
3654 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[0]);
3655 par = unur_tdr_new(distr_localcopy);
3656 unur_tdr_set_pedantic(par,0);
3657 unur_tdr_set_variant_ia(par);
3658 unur_tdr_set_c(par,0.);
3659 gen = unur_init(par);
3660 if (gen) unur_tdr_chg_verify(gen,1);
3661 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[0],'~')==UNUR_SUCCESS)?0:1000;
3662 unur_free(gen);
3663
3664 unur_distr_free(distr_localcopy);
3665 } while (0);
3666 }
3667
3668 if(fullcheck) {
3669 unur_reset_errno();
3670 do {
3671 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[0]);
3672 par = unur_tdr_new(distr_localcopy);
3673 unur_tdr_set_pedantic(par,0);
3674 unur_tdr_set_variant_ia(par);
3675 unur_tdr_set_c(par,-0.5);
3676 unur_tdr_set_cpoints(par,30,NULL);
3677 unur_set_use_distr_privatecopy(par,FALSE);
3678 fpm[0] = 1.;
3679 fpm[1] = 4.;
3680 unur_distr_cont_set_pdfparams(distr_localcopy,fpm,2);
3681 gen = unur_init(par);
3682 if (gen) {
3683 unur_tdr_chg_reinit_percentiles(gen, 2, NULL );
3684 unur_reinit(gen);
3685 }
3686 if (gen) unur_tdr_chg_verify(gen,1);
3687 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[0],'~')==UNUR_SUCCESS)?0:1000;
3688 unur_free(gen);
3689
3690 unur_distr_free(distr_localcopy);
3691 } while (0);
3692 }
3693
3694 if(fullcheck) {
3695 unur_reset_errno();
3696 do {
3697 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[0]);
3698 par = unur_tdr_new(distr_localcopy);
3699 unur_tdr_set_pedantic(par,0);
3700 unur_tdr_set_variant_ia(par);
3701 unur_tdr_set_c(par,0.);
3702 unur_tdr_set_cpoints(par,30,NULL);
3703 unur_set_use_distr_privatecopy(par,FALSE);
3704 fpm[0] = 1.;
3705 fpm[1] = 4.;
3706 unur_distr_cont_set_pdfparams(distr_localcopy,fpm,2);
3707 gen = unur_init(par);
3708 if (gen) {
3709 unur_tdr_chg_reinit_percentiles(gen, 2, NULL );
3710 unur_reinit(gen);
3711 }
3712 if (gen) unur_tdr_chg_verify(gen,1);
3713 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[0],'~')==UNUR_SUCCESS)?0:1000;
3714 unur_free(gen);
3715
3716 unur_distr_free(distr_localcopy);
3717 } while (0);
3718 }
3719
3720 /* distribution [1] */
3721
3722 if(TRUE) {
3723 unur_reset_errno();
3724 do {
3725 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[1]);
3726 par = unur_tdr_new(distr_localcopy);
3727 unur_tdr_set_pedantic(par,0);
3728 unur_tdr_set_variant_ia(par);
3729 unur_tdr_set_c(par,-0.5);
3730 gen = unur_init(par);
3731 if (gen) unur_tdr_chg_verify(gen,1);
3732 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[1],'~')==UNUR_SUCCESS)?0:1000;
3733 unur_free(gen);
3734
3735 unur_distr_free(distr_localcopy);
3736 } while (0);
3737 }
3738
3739 if(TRUE) {
3740 unur_reset_errno();
3741 do {
3742 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[1]);
3743 par = unur_tdr_new(distr_localcopy);
3744 unur_tdr_set_pedantic(par,0);
3745 unur_tdr_set_variant_ia(par);
3746 unur_tdr_set_c(par,-0.5);
3747 unur_tdr_set_usedars(par,FALSE);
3748 unur_tdr_set_cpoints(par,10,NULL);
3749 gen = unur_init(par);
3750 if (gen) unur_tdr_chg_verify(gen,1);
3751 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[1],'~')==UNUR_SUCCESS)?0:1000;
3752 unur_free(gen);
3753
3754 unur_distr_free(distr_localcopy);
3755 } while (0);
3756 }
3757
3758 if(TRUE) {
3759 unur_reset_errno();
3760 do {
3761 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[1]);
3762 par = unur_tdr_new(distr_localcopy);
3763 unur_tdr_set_pedantic(par,0);
3764 unur_tdr_set_variant_ia(par);
3765 unur_tdr_set_c(par,-0.5);
3766 unur_tdr_set_usedars(par,FALSE);
3767 unur_tdr_set_cpoints(par,10,NULL);
3768 unur_tdr_set_max_sqhratio(par,0.25);
3769 gen = unur_init(par);
3770 if (gen) unur_tdr_chg_verify(gen,1);
3771 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[1],'~')==UNUR_SUCCESS)?0:1000;
3772 unur_free(gen);
3773
3774 unur_distr_free(distr_localcopy);
3775 } while (0);
3776 }
3777
3778 if(TRUE) {
3779 unur_reset_errno();
3780 do {
3781 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[1]);
3782 par = unur_tdr_new(distr_localcopy);
3783 unur_tdr_set_pedantic(par,0);
3784 unur_tdr_set_variant_ia(par);
3785 unur_tdr_set_c(par,0.);
3786 gen = unur_init(par);
3787 if (gen) unur_tdr_chg_verify(gen,1);
3788 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[1],'~')==UNUR_SUCCESS)?0:1000;
3789 unur_free(gen);
3790
3791 unur_distr_free(distr_localcopy);
3792 } while (0);
3793 }
3794
3795 if(TRUE) {
3796 printf("."); fflush(stdout);
3797 }
3798
3799 if(TRUE) {
3800 printf("."); fflush(stdout);
3801 }
3802
3803 /* distribution [2] */
3804
3805 if(fullcheck) {
3806 unur_reset_errno();
3807 do {
3808 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[2]);
3809 par = unur_tdr_new(distr_localcopy);
3810 unur_tdr_set_pedantic(par,0);
3811 unur_tdr_set_variant_ia(par);
3812 unur_tdr_set_c(par,-0.5);
3813 gen = unur_init(par);
3814 if (gen) unur_tdr_chg_verify(gen,1);
3815 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[2],'~')==UNUR_SUCCESS)?0:1000;
3816 unur_free(gen);
3817
3818 unur_distr_free(distr_localcopy);
3819 } while (0);
3820 }
3821
3822 if(fullcheck) {
3823 unur_reset_errno();
3824 do {
3825 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[2]);
3826 par = unur_tdr_new(distr_localcopy);
3827 unur_tdr_set_pedantic(par,0);
3828 unur_tdr_set_variant_ia(par);
3829 unur_tdr_set_c(par,-0.5);
3830 unur_tdr_set_usedars(par,FALSE);
3831 unur_tdr_set_cpoints(par,10,NULL);
3832 gen = unur_init(par);
3833 if (gen) unur_tdr_chg_verify(gen,1);
3834 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[2],'~')==UNUR_SUCCESS)?0:1000;
3835 unur_free(gen);
3836
3837 unur_distr_free(distr_localcopy);
3838 } while (0);
3839 }
3840
3841 if(fullcheck) {
3842 unur_reset_errno();
3843 do {
3844 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[2]);
3845 par = unur_tdr_new(distr_localcopy);
3846 unur_tdr_set_pedantic(par,0);
3847 unur_tdr_set_variant_ia(par);
3848 unur_tdr_set_c(par,-0.5);
3849 unur_tdr_set_usedars(par,FALSE);
3850 unur_tdr_set_cpoints(par,10,NULL);
3851 unur_tdr_set_max_sqhratio(par,0.25);
3852 gen = unur_init(par);
3853 if (gen) unur_tdr_chg_verify(gen,1);
3854 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[2],'~')==UNUR_SUCCESS)?0:1000;
3855 unur_free(gen);
3856
3857 unur_distr_free(distr_localcopy);
3858 } while (0);
3859 }
3860
3861 if(fullcheck) {
3862 unur_reset_errno();
3863 do {
3864 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[2]);
3865 par = unur_tdr_new(distr_localcopy);
3866 unur_tdr_set_pedantic(par,0);
3867 unur_tdr_set_variant_ia(par);
3868 unur_tdr_set_c(par,0.);
3869 gen = unur_init(par);
3870 if (gen) unur_tdr_chg_verify(gen,1);
3871 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[2],'~')==UNUR_SUCCESS)?0:1000;
3872 unur_free(gen);
3873
3874 unur_distr_free(distr_localcopy);
3875 } while (0);
3876 }
3877
3878 if(fullcheck) {
3879 unur_reset_errno();
3880 do {
3881 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[2]);
3882 par = unur_tdr_new(distr_localcopy);
3883 unur_tdr_set_pedantic(par,0);
3884 unur_tdr_set_variant_ia(par);
3885 unur_tdr_set_c(par,-0.5);
3886 unur_tdr_set_cpoints(par,30,NULL);
3887 unur_set_use_distr_privatecopy(par,FALSE);
3888 fpm[0] = 1.;
3889 fpm[1] = 4.;
3890 unur_distr_cont_set_pdfparams(distr_localcopy,fpm,2);
3891 gen = unur_init(par);
3892 if (gen) {
3893 unur_tdr_chg_reinit_percentiles(gen, 2, NULL );
3894 unur_reinit(gen);
3895 }
3896 if (gen) unur_tdr_chg_verify(gen,1);
3897 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[2],'~')==UNUR_SUCCESS)?0:1000;
3898 unur_free(gen);
3899
3900 unur_distr_free(distr_localcopy);
3901 } while (0);
3902 }
3903
3904 if(fullcheck) {
3905 unur_reset_errno();
3906 do {
3907 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[2]);
3908 par = unur_tdr_new(distr_localcopy);
3909 unur_tdr_set_pedantic(par,0);
3910 unur_tdr_set_variant_ia(par);
3911 unur_tdr_set_c(par,0.);
3912 unur_tdr_set_cpoints(par,30,NULL);
3913 unur_set_use_distr_privatecopy(par,FALSE);
3914 fpm[0] = 1.;
3915 fpm[1] = 4.;
3916 unur_distr_cont_set_pdfparams(distr_localcopy,fpm,2);
3917 gen = unur_init(par);
3918 if (gen) {
3919 unur_tdr_chg_reinit_percentiles(gen, 2, NULL );
3920 unur_reinit(gen);
3921 }
3922 if (gen) unur_tdr_chg_verify(gen,1);
3923 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[2],'~')==UNUR_SUCCESS)?0:1000;
3924 unur_free(gen);
3925
3926 unur_distr_free(distr_localcopy);
3927 } while (0);
3928 }
3929
3930 /* distribution [30] */
3931
3932 if(TRUE) {
3933 unur_reset_errno();
3934 do {
3935 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[30]);
3936 par = unur_tdr_new(distr_localcopy);
3937 unur_tdr_set_pedantic(par,0);
3938 unur_tdr_set_variant_ia(par);
3939 unur_tdr_set_c(par,-0.5);
3940 gen = unur_init(par);
3941 if (gen) unur_tdr_chg_verify(gen,1);
3942 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[30],'~')==UNUR_SUCCESS)?0:1000;
3943 unur_free(gen);
3944
3945 unur_distr_free(distr_localcopy);
3946 } while (0);
3947 }
3948
3949 if(TRUE) {
3950 unur_reset_errno();
3951 do {
3952 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[30]);
3953 par = unur_tdr_new(distr_localcopy);
3954 unur_tdr_set_pedantic(par,0);
3955 unur_tdr_set_variant_ia(par);
3956 unur_tdr_set_c(par,-0.5);
3957 unur_tdr_set_usedars(par,FALSE);
3958 unur_tdr_set_cpoints(par,10,NULL);
3959 gen = unur_init(par);
3960 if (gen) unur_tdr_chg_verify(gen,1);
3961 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[30],'~')==UNUR_SUCCESS)?0:1000;
3962 unur_free(gen);
3963
3964 unur_distr_free(distr_localcopy);
3965 } while (0);
3966 }
3967
3968 if(TRUE) {
3969 unur_reset_errno();
3970 do {
3971 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[30]);
3972 par = unur_tdr_new(distr_localcopy);
3973 unur_tdr_set_pedantic(par,0);
3974 unur_tdr_set_variant_ia(par);
3975 unur_tdr_set_c(par,-0.5);
3976 unur_tdr_set_usedars(par,FALSE);
3977 unur_tdr_set_cpoints(par,10,NULL);
3978 unur_tdr_set_max_sqhratio(par,0.25);
3979 gen = unur_init(par);
3980 if (gen) unur_tdr_chg_verify(gen,1);
3981 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[30],'~')==UNUR_SUCCESS)?0:1000;
3982 unur_free(gen);
3983
3984 unur_distr_free(distr_localcopy);
3985 } while (0);
3986 }
3987
3988 if(TRUE) {
3989 unur_reset_errno();
3990 do {
3991 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[30]);
3992 par = unur_tdr_new(distr_localcopy);
3993 unur_tdr_set_pedantic(par,0);
3994 unur_tdr_set_variant_ia(par);
3995 unur_tdr_set_c(par,0.);
3996 gen = unur_init(par);
3997 if (gen) unur_tdr_chg_verify(gen,1);
3998 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[30],'~')==UNUR_SUCCESS)?0:1000;
3999 unur_free(gen);
4000
4001 unur_distr_free(distr_localcopy);
4002 } while (0);
4003 }
4004
4005 if(TRUE) {
4006 printf("."); fflush(stdout);
4007 }
4008
4009 if(TRUE) {
4010 printf("."); fflush(stdout);
4011 }
4012
4013 /* distribution [31] */
4014
4015 if(TRUE) {
4016 unur_reset_errno();
4017 do {
4018 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[31]);
4019 par = unur_tdr_new(distr_localcopy);
4020 unur_tdr_set_pedantic(par,0);
4021 unur_tdr_set_variant_ia(par);
4022 unur_tdr_set_c(par,-0.5);
4023 gen = unur_init(par);
4024 if (gen) unur_tdr_chg_verify(gen,1);
4025 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[31],'~')==UNUR_SUCCESS)?0:1000;
4026 unur_free(gen);
4027
4028 unur_distr_free(distr_localcopy);
4029 } while (0);
4030 }
4031
4032 if(TRUE) {
4033 unur_reset_errno();
4034 do {
4035 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[31]);
4036 par = unur_tdr_new(distr_localcopy);
4037 unur_tdr_set_pedantic(par,0);
4038 unur_tdr_set_variant_ia(par);
4039 unur_tdr_set_c(par,-0.5);
4040 unur_tdr_set_usedars(par,FALSE);
4041 unur_tdr_set_cpoints(par,10,NULL);
4042 gen = unur_init(par);
4043 if (gen) unur_tdr_chg_verify(gen,1);
4044 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[31],'~')==UNUR_SUCCESS)?0:1000;
4045 unur_free(gen);
4046
4047 unur_distr_free(distr_localcopy);
4048 } while (0);
4049 }
4050
4051 if(TRUE) {
4052 unur_reset_errno();
4053 do {
4054 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[31]);
4055 par = unur_tdr_new(distr_localcopy);
4056 unur_tdr_set_pedantic(par,0);
4057 unur_tdr_set_variant_ia(par);
4058 unur_tdr_set_c(par,-0.5);
4059 unur_tdr_set_usedars(par,FALSE);
4060 unur_tdr_set_cpoints(par,10,NULL);
4061 unur_tdr_set_max_sqhratio(par,0.25);
4062 gen = unur_init(par);
4063 if (gen) unur_tdr_chg_verify(gen,1);
4064 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[31],'~')==UNUR_SUCCESS)?0:1000;
4065 unur_free(gen);
4066
4067 unur_distr_free(distr_localcopy);
4068 } while (0);
4069 }
4070
4071 if(TRUE) {
4072 unur_reset_errno();
4073 do {
4074 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[31]);
4075 par = unur_tdr_new(distr_localcopy);
4076 unur_tdr_set_pedantic(par,0);
4077 unur_tdr_set_variant_ia(par);
4078 unur_tdr_set_c(par,0.);
4079 gen = unur_init(par);
4080 if (gen) unur_tdr_chg_verify(gen,1);
4081 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[31],'~')==UNUR_SUCCESS)?0:1000;
4082 unur_free(gen);
4083
4084 unur_distr_free(distr_localcopy);
4085 } while (0);
4086 }
4087
4088 if(TRUE) {
4089 unur_reset_errno();
4090 do {
4091 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[31]);
4092 par = unur_tdr_new(distr_localcopy);
4093 unur_tdr_set_pedantic(par,0);
4094 unur_tdr_set_variant_ia(par);
4095 unur_tdr_set_c(par,-0.5);
4096 unur_tdr_set_cpoints(par,30,NULL);
4097 unur_set_use_distr_privatecopy(par,FALSE);
4098 fpm[0] = 1.;
4099 fpm[1] = 4.;
4100 unur_distr_cont_set_pdfparams(distr_localcopy,fpm,2);
4101 gen = unur_init(par);
4102 if (gen) {
4103 unur_tdr_chg_reinit_percentiles(gen, 2, NULL );
4104 unur_reinit(gen);
4105 }
4106 if (gen) unur_tdr_chg_verify(gen,1);
4107 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[31],'~')==UNUR_SUCCESS)?0:1000;
4108 unur_free(gen);
4109
4110 unur_distr_free(distr_localcopy);
4111 } while (0);
4112 }
4113
4114 if(TRUE) {
4115 unur_reset_errno();
4116 do {
4117 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[31]);
4118 par = unur_tdr_new(distr_localcopy);
4119 unur_tdr_set_pedantic(par,0);
4120 unur_tdr_set_variant_ia(par);
4121 unur_tdr_set_c(par,0.);
4122 unur_tdr_set_cpoints(par,30,NULL);
4123 unur_set_use_distr_privatecopy(par,FALSE);
4124 fpm[0] = 1.;
4125 fpm[1] = 4.;
4126 unur_distr_cont_set_pdfparams(distr_localcopy,fpm,2);
4127 gen = unur_init(par);
4128 if (gen) {
4129 unur_tdr_chg_reinit_percentiles(gen, 2, NULL );
4130 unur_reinit(gen);
4131 }
4132 if (gen) unur_tdr_chg_verify(gen,1);
4133 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[31],'~')==UNUR_SUCCESS)?0:1000;
4134 unur_free(gen);
4135
4136 unur_distr_free(distr_localcopy);
4137 } while (0);
4138 }
4139
4140 /* distribution [3] */
4141
4142 if(TRUE) {
4143 unur_reset_errno();
4144 do {
4145 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[3]);
4146 par = unur_tdr_new(distr_localcopy);
4147 unur_tdr_set_pedantic(par,0);
4148 unur_tdr_set_variant_ia(par);
4149 unur_tdr_set_c(par,-0.5);
4150 gen = unur_init(par);
4151 if (gen) unur_tdr_chg_verify(gen,1);
4152 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[3],'~')==UNUR_SUCCESS)?0:1000;
4153 unur_free(gen);
4154
4155 unur_distr_free(distr_localcopy);
4156 } while (0);
4157 }
4158
4159 if(TRUE) {
4160 unur_reset_errno();
4161 do {
4162 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[3]);
4163 par = unur_tdr_new(distr_localcopy);
4164 unur_tdr_set_pedantic(par,0);
4165 unur_tdr_set_variant_ia(par);
4166 unur_tdr_set_c(par,-0.5);
4167 unur_tdr_set_usedars(par,FALSE);
4168 unur_tdr_set_cpoints(par,10,NULL);
4169 gen = unur_init(par);
4170 if (gen) unur_tdr_chg_verify(gen,1);
4171 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[3],'~')==UNUR_SUCCESS)?0:1000;
4172 unur_free(gen);
4173
4174 unur_distr_free(distr_localcopy);
4175 } while (0);
4176 }
4177
4178 if(TRUE) {
4179 unur_reset_errno();
4180 do {
4181 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[3]);
4182 par = unur_tdr_new(distr_localcopy);
4183 unur_tdr_set_pedantic(par,0);
4184 unur_tdr_set_variant_ia(par);
4185 unur_tdr_set_c(par,-0.5);
4186 unur_tdr_set_usedars(par,FALSE);
4187 unur_tdr_set_cpoints(par,10,NULL);
4188 unur_tdr_set_max_sqhratio(par,0.25);
4189 gen = unur_init(par);
4190 if (gen) unur_tdr_chg_verify(gen,1);
4191 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[3],'~')==UNUR_SUCCESS)?0:1000;
4192 unur_free(gen);
4193
4194 unur_distr_free(distr_localcopy);
4195 } while (0);
4196 }
4197
4198 if(TRUE) {
4199 unur_reset_errno();
4200 do {
4201 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[3]);
4202 par = unur_tdr_new(distr_localcopy);
4203 unur_tdr_set_pedantic(par,0);
4204 unur_tdr_set_variant_ia(par);
4205 unur_tdr_set_c(par,0.);
4206 gen = unur_init(par);
4207 if (gen) unur_tdr_chg_verify(gen,1);
4208 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[3],'~')==UNUR_SUCCESS)?0:1000;
4209 unur_free(gen);
4210
4211 unur_distr_free(distr_localcopy);
4212 } while (0);
4213 }
4214
4215 if(TRUE) {
4216 printf("."); fflush(stdout);
4217 }
4218
4219 if(TRUE) {
4220 printf("."); fflush(stdout);
4221 }
4222
4223 /* distribution [4] */
4224
4225 if(TRUE) {
4226 unur_reset_errno();
4227 do {
4228 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[4]);
4229 par = unur_tdr_new(distr_localcopy);
4230 unur_tdr_set_pedantic(par,0);
4231 unur_tdr_set_variant_ia(par);
4232 unur_tdr_set_c(par,-0.5);
4233 gen = unur_init(par);
4234 if (gen) unur_tdr_chg_verify(gen,1);
4235 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[4],'~')==UNUR_SUCCESS)?0:1000;
4236 unur_free(gen);
4237
4238 unur_distr_free(distr_localcopy);
4239 } while (0);
4240 }
4241
4242 if(TRUE) {
4243 unur_reset_errno();
4244 do {
4245 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[4]);
4246 par = unur_tdr_new(distr_localcopy);
4247 unur_tdr_set_pedantic(par,0);
4248 unur_tdr_set_variant_ia(par);
4249 unur_tdr_set_c(par,-0.5);
4250 unur_tdr_set_usedars(par,FALSE);
4251 unur_tdr_set_cpoints(par,10,NULL);
4252 gen = unur_init(par);
4253 if (gen) unur_tdr_chg_verify(gen,1);
4254 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[4],'~')==UNUR_SUCCESS)?0:1000;
4255 unur_free(gen);
4256
4257 unur_distr_free(distr_localcopy);
4258 } while (0);
4259 }
4260
4261 if(TRUE) {
4262 unur_reset_errno();
4263 do {
4264 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[4]);
4265 par = unur_tdr_new(distr_localcopy);
4266 unur_tdr_set_pedantic(par,0);
4267 unur_tdr_set_variant_ia(par);
4268 unur_tdr_set_c(par,-0.5);
4269 unur_tdr_set_usedars(par,FALSE);
4270 unur_tdr_set_cpoints(par,10,NULL);
4271 unur_tdr_set_max_sqhratio(par,0.25);
4272 gen = unur_init(par);
4273 if (gen) unur_tdr_chg_verify(gen,1);
4274 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[4],'~')==UNUR_SUCCESS)?0:1000;
4275 unur_free(gen);
4276
4277 unur_distr_free(distr_localcopy);
4278 } while (0);
4279 }
4280
4281 if(TRUE) {
4282 unur_reset_errno();
4283 do {
4284 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[4]);
4285 par = unur_tdr_new(distr_localcopy);
4286 unur_tdr_set_pedantic(par,0);
4287 unur_tdr_set_variant_ia(par);
4288 unur_tdr_set_c(par,0.);
4289 gen = unur_init(par);
4290 if (gen) unur_tdr_chg_verify(gen,1);
4291 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[4],'~')==UNUR_SUCCESS)?0:1000;
4292 unur_free(gen);
4293
4294 unur_distr_free(distr_localcopy);
4295 } while (0);
4296 }
4297
4298 if(TRUE) {
4299 printf("."); fflush(stdout);
4300 }
4301
4302 if(TRUE) {
4303 printf("."); fflush(stdout);
4304 }
4305
4306 /* distribution [5] */
4307
4308 if(TRUE) {
4309 unur_reset_errno();
4310 do {
4311 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[5]);
4312 par = unur_tdr_new(distr_localcopy);
4313 unur_tdr_set_pedantic(par,0);
4314 unur_tdr_set_variant_ia(par);
4315 unur_tdr_set_c(par,-0.5);
4316 gen = unur_init(par);
4317 if (gen) unur_tdr_chg_verify(gen,1);
4318 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[5],'~')==UNUR_SUCCESS)?0:1000;
4319 unur_free(gen);
4320
4321 unur_distr_free(distr_localcopy);
4322 } while (0);
4323 }
4324
4325 if(TRUE) {
4326 unur_reset_errno();
4327 do {
4328 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[5]);
4329 par = unur_tdr_new(distr_localcopy);
4330 unur_tdr_set_pedantic(par,0);
4331 unur_tdr_set_variant_ia(par);
4332 unur_tdr_set_c(par,-0.5);
4333 unur_tdr_set_usedars(par,FALSE);
4334 unur_tdr_set_cpoints(par,10,NULL);
4335 gen = unur_init(par);
4336 if (gen) unur_tdr_chg_verify(gen,1);
4337 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[5],'~')==UNUR_SUCCESS)?0:1000;
4338 unur_free(gen);
4339
4340 unur_distr_free(distr_localcopy);
4341 } while (0);
4342 }
4343
4344 if(TRUE) {
4345 unur_reset_errno();
4346 do {
4347 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[5]);
4348 par = unur_tdr_new(distr_localcopy);
4349 unur_tdr_set_pedantic(par,0);
4350 unur_tdr_set_variant_ia(par);
4351 unur_tdr_set_c(par,-0.5);
4352 unur_tdr_set_usedars(par,FALSE);
4353 unur_tdr_set_cpoints(par,10,NULL);
4354 unur_tdr_set_max_sqhratio(par,0.25);
4355 gen = unur_init(par);
4356 if (gen) unur_tdr_chg_verify(gen,1);
4357 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[5],'~')==UNUR_SUCCESS)?0:1000;
4358 unur_free(gen);
4359
4360 unur_distr_free(distr_localcopy);
4361 } while (0);
4362 }
4363
4364 if(TRUE) {
4365 unur_reset_errno();
4366 do {
4367 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[5]);
4368 par = unur_tdr_new(distr_localcopy);
4369 unur_tdr_set_pedantic(par,0);
4370 unur_tdr_set_variant_ia(par);
4371 unur_tdr_set_c(par,0.);
4372 gen = unur_init(par);
4373 if (gen) unur_tdr_chg_verify(gen,1);
4374 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[5],'~')==UNUR_SUCCESS)?0:1000;
4375 unur_free(gen);
4376
4377 unur_distr_free(distr_localcopy);
4378 } while (0);
4379 }
4380
4381 if(TRUE) {
4382 unur_reset_errno();
4383 do {
4384 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[5]);
4385 par = unur_tdr_new(distr_localcopy);
4386 unur_tdr_set_pedantic(par,0);
4387 unur_tdr_set_variant_ia(par);
4388 unur_tdr_set_c(par,-0.5);
4389 unur_tdr_set_cpoints(par,30,NULL);
4390 unur_set_use_distr_privatecopy(par,FALSE);
4391 fpm[0] = 1.;
4392 fpm[1] = 4.;
4393 unur_distr_cont_set_pdfparams(distr_localcopy,fpm,2);
4394 gen = unur_init(par);
4395 if (gen) {
4396 unur_tdr_chg_reinit_percentiles(gen, 2, NULL );
4397 unur_reinit(gen);
4398 }
4399 if (gen) unur_tdr_chg_verify(gen,1);
4400 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[5],'~')==UNUR_SUCCESS)?0:1000;
4401 unur_free(gen);
4402
4403 unur_distr_free(distr_localcopy);
4404 } while (0);
4405 }
4406
4407 if(TRUE) {
4408 unur_reset_errno();
4409 do {
4410 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[5]);
4411 par = unur_tdr_new(distr_localcopy);
4412 unur_tdr_set_pedantic(par,0);
4413 unur_tdr_set_variant_ia(par);
4414 unur_tdr_set_c(par,0.);
4415 unur_tdr_set_cpoints(par,30,NULL);
4416 unur_set_use_distr_privatecopy(par,FALSE);
4417 fpm[0] = 1.;
4418 fpm[1] = 4.;
4419 unur_distr_cont_set_pdfparams(distr_localcopy,fpm,2);
4420 gen = unur_init(par);
4421 if (gen) {
4422 unur_tdr_chg_reinit_percentiles(gen, 2, NULL );
4423 unur_reinit(gen);
4424 }
4425 if (gen) unur_tdr_chg_verify(gen,1);
4426 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[5],'~')==UNUR_SUCCESS)?0:1000;
4427 unur_free(gen);
4428
4429 unur_distr_free(distr_localcopy);
4430 } while (0);
4431 }
4432
4433 /* distribution [6] */
4434
4435 if(TRUE) {
4436 unur_reset_errno();
4437 do {
4438 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[6]);
4439 par = unur_tdr_new(distr_localcopy);
4440 unur_tdr_set_pedantic(par,0);
4441 unur_tdr_set_variant_ia(par);
4442 unur_tdr_set_c(par,-0.5);
4443 gen = unur_init(par);
4444 if (gen) unur_tdr_chg_verify(gen,1);
4445 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[6],'~')==UNUR_SUCCESS)?0:1000;
4446 unur_free(gen);
4447
4448 unur_distr_free(distr_localcopy);
4449 } while (0);
4450 }
4451
4452 if(TRUE) {
4453 unur_reset_errno();
4454 do {
4455 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[6]);
4456 par = unur_tdr_new(distr_localcopy);
4457 unur_tdr_set_pedantic(par,0);
4458 unur_tdr_set_variant_ia(par);
4459 unur_tdr_set_c(par,-0.5);
4460 unur_tdr_set_usedars(par,FALSE);
4461 unur_tdr_set_cpoints(par,10,NULL);
4462 gen = unur_init(par);
4463 if (gen) unur_tdr_chg_verify(gen,1);
4464 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[6],'~')==UNUR_SUCCESS)?0:1000;
4465 unur_free(gen);
4466
4467 unur_distr_free(distr_localcopy);
4468 } while (0);
4469 }
4470
4471 if(TRUE) {
4472 unur_reset_errno();
4473 do {
4474 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[6]);
4475 par = unur_tdr_new(distr_localcopy);
4476 unur_tdr_set_pedantic(par,0);
4477 unur_tdr_set_variant_ia(par);
4478 unur_tdr_set_c(par,-0.5);
4479 unur_tdr_set_usedars(par,FALSE);
4480 unur_tdr_set_cpoints(par,10,NULL);
4481 unur_tdr_set_max_sqhratio(par,0.25);
4482 gen = unur_init(par);
4483 if (gen) unur_tdr_chg_verify(gen,1);
4484 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[6],'~')==UNUR_SUCCESS)?0:1000;
4485 unur_free(gen);
4486
4487 unur_distr_free(distr_localcopy);
4488 } while (0);
4489 }
4490
4491 if(TRUE) {
4492 unur_reset_errno();
4493 do {
4494 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[6]);
4495 par = unur_tdr_new(distr_localcopy);
4496 unur_tdr_set_pedantic(par,0);
4497 unur_tdr_set_variant_ia(par);
4498 unur_tdr_set_c(par,0.);
4499 gen = unur_init(par);
4500 if (gen) unur_tdr_chg_verify(gen,1);
4501 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[6],'~')==UNUR_SUCCESS)?0:1000;
4502 unur_free(gen);
4503
4504 unur_distr_free(distr_localcopy);
4505 } while (0);
4506 }
4507
4508 if(TRUE) {
4509 unur_reset_errno();
4510 do {
4511 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[6]);
4512 par = unur_tdr_new(distr_localcopy);
4513 unur_tdr_set_pedantic(par,0);
4514 unur_tdr_set_variant_ia(par);
4515 unur_tdr_set_c(par,-0.5);
4516 unur_tdr_set_cpoints(par,30,NULL);
4517 unur_set_use_distr_privatecopy(par,FALSE);
4518 fpm[0] = 1.;
4519 fpm[1] = 4.;
4520 unur_distr_cont_set_pdfparams(distr_localcopy,fpm,2);
4521 gen = unur_init(par);
4522 if (gen) {
4523 unur_tdr_chg_reinit_percentiles(gen, 2, NULL );
4524 unur_reinit(gen);
4525 }
4526 if (gen) unur_tdr_chg_verify(gen,1);
4527 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[6],'~')==UNUR_SUCCESS)?0:1000;
4528 unur_free(gen);
4529
4530 unur_distr_free(distr_localcopy);
4531 } while (0);
4532 }
4533
4534 if(TRUE) {
4535 unur_reset_errno();
4536 do {
4537 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[6]);
4538 par = unur_tdr_new(distr_localcopy);
4539 unur_tdr_set_pedantic(par,0);
4540 unur_tdr_set_variant_ia(par);
4541 unur_tdr_set_c(par,0.);
4542 unur_tdr_set_cpoints(par,30,NULL);
4543 unur_set_use_distr_privatecopy(par,FALSE);
4544 fpm[0] = 1.;
4545 fpm[1] = 4.;
4546 unur_distr_cont_set_pdfparams(distr_localcopy,fpm,2);
4547 gen = unur_init(par);
4548 if (gen) {
4549 unur_tdr_chg_reinit_percentiles(gen, 2, NULL );
4550 unur_reinit(gen);
4551 }
4552 if (gen) unur_tdr_chg_verify(gen,1);
4553 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[6],'~')==UNUR_SUCCESS)?0:1000;
4554 unur_free(gen);
4555
4556 unur_distr_free(distr_localcopy);
4557 } while (0);
4558 }
4559
4560 /* distribution [7] */
4561
4562 if(TRUE) {
4563 unur_reset_errno();
4564 do {
4565 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[7]);
4566 par = unur_tdr_new(distr_localcopy);
4567 unur_tdr_set_pedantic(par,0);
4568 unur_tdr_set_variant_ia(par);
4569 unur_tdr_set_c(par,-0.5);
4570 gen = unur_init(par);
4571 if (gen) unur_tdr_chg_verify(gen,1);
4572 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[7],'~')==UNUR_SUCCESS)?0:1000;
4573 unur_free(gen);
4574
4575 unur_distr_free(distr_localcopy);
4576 } while (0);
4577 }
4578
4579 if(TRUE) {
4580 unur_reset_errno();
4581 do {
4582 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[7]);
4583 par = unur_tdr_new(distr_localcopy);
4584 unur_tdr_set_pedantic(par,0);
4585 unur_tdr_set_variant_ia(par);
4586 unur_tdr_set_c(par,-0.5);
4587 unur_tdr_set_usedars(par,FALSE);
4588 unur_tdr_set_cpoints(par,10,NULL);
4589 gen = unur_init(par);
4590 if (gen) unur_tdr_chg_verify(gen,1);
4591 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[7],'~')==UNUR_SUCCESS)?0:1000;
4592 unur_free(gen);
4593
4594 unur_distr_free(distr_localcopy);
4595 } while (0);
4596 }
4597
4598 if(TRUE) {
4599 unur_reset_errno();
4600 do {
4601 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[7]);
4602 par = unur_tdr_new(distr_localcopy);
4603 unur_tdr_set_pedantic(par,0);
4604 unur_tdr_set_variant_ia(par);
4605 unur_tdr_set_c(par,-0.5);
4606 unur_tdr_set_usedars(par,FALSE);
4607 unur_tdr_set_cpoints(par,10,NULL);
4608 unur_tdr_set_max_sqhratio(par,0.25);
4609 gen = unur_init(par);
4610 if (gen) unur_tdr_chg_verify(gen,1);
4611 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[7],'~')==UNUR_SUCCESS)?0:1000;
4612 unur_free(gen);
4613
4614 unur_distr_free(distr_localcopy);
4615 } while (0);
4616 }
4617
4618 if(TRUE) {
4619 unur_reset_errno();
4620 do {
4621 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[7]);
4622 par = unur_tdr_new(distr_localcopy);
4623 unur_tdr_set_pedantic(par,0);
4624 unur_tdr_set_variant_ia(par);
4625 unur_tdr_set_c(par,0.);
4626 gen = unur_init(par);
4627 if (gen) unur_tdr_chg_verify(gen,1);
4628 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[7],'0')==UNUR_SUCCESS)?0:1000;
4629 unur_free(gen);
4630
4631 unur_distr_free(distr_localcopy);
4632 } while (0);
4633 }
4634
4635 if(TRUE) {
4636 unur_reset_errno();
4637 do {
4638 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[7]);
4639 par = unur_tdr_new(distr_localcopy);
4640 unur_tdr_set_pedantic(par,0);
4641 unur_tdr_set_variant_ia(par);
4642 unur_tdr_set_c(par,-0.5);
4643 unur_tdr_set_cpoints(par,30,NULL);
4644 unur_set_use_distr_privatecopy(par,FALSE);
4645 fpm[0] = 1.;
4646 fpm[1] = 4.;
4647 unur_distr_cont_set_pdfparams(distr_localcopy,fpm,2);
4648 gen = unur_init(par);
4649 if (gen) {
4650 unur_tdr_chg_reinit_percentiles(gen, 2, NULL );
4651 unur_reinit(gen);
4652 }
4653 if (gen) unur_tdr_chg_verify(gen,1);
4654 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[7],'~')==UNUR_SUCCESS)?0:1000;
4655 unur_free(gen);
4656
4657 unur_distr_free(distr_localcopy);
4658 } while (0);
4659 }
4660
4661 if(TRUE) {
4662 unur_reset_errno();
4663 do {
4664 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[7]);
4665 par = unur_tdr_new(distr_localcopy);
4666 unur_tdr_set_pedantic(par,0);
4667 unur_tdr_set_variant_ia(par);
4668 unur_tdr_set_c(par,0.);
4669 unur_tdr_set_cpoints(par,30,NULL);
4670 unur_set_use_distr_privatecopy(par,FALSE);
4671 fpm[0] = 1.;
4672 fpm[1] = 4.;
4673 unur_distr_cont_set_pdfparams(distr_localcopy,fpm,2);
4674 gen = unur_init(par);
4675 if (gen) {
4676 unur_tdr_chg_reinit_percentiles(gen, 2, NULL );
4677 unur_reinit(gen);
4678 }
4679 if (gen) unur_tdr_chg_verify(gen,1);
4680 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[7],'0')==UNUR_SUCCESS)?0:1000;
4681 unur_free(gen);
4682
4683 unur_distr_free(distr_localcopy);
4684 } while (0);
4685 }
4686
4687 /* distribution [8] */
4688
4689 if(TRUE) {
4690 unur_reset_errno();
4691 do {
4692 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[8]);
4693 par = unur_tdr_new(distr_localcopy);
4694 unur_tdr_set_pedantic(par,0);
4695 unur_tdr_set_variant_ia(par);
4696 unur_tdr_set_c(par,-0.5);
4697 gen = unur_init(par);
4698 if (gen) unur_tdr_chg_verify(gen,1);
4699 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[8],'~')==UNUR_SUCCESS)?0:1000;
4700 unur_free(gen);
4701
4702 unur_distr_free(distr_localcopy);
4703 } while (0);
4704 }
4705
4706 if(TRUE) {
4707 unur_reset_errno();
4708 do {
4709 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[8]);
4710 par = unur_tdr_new(distr_localcopy);
4711 unur_tdr_set_pedantic(par,0);
4712 unur_tdr_set_variant_ia(par);
4713 unur_tdr_set_c(par,-0.5);
4714 unur_tdr_set_usedars(par,FALSE);
4715 unur_tdr_set_cpoints(par,10,NULL);
4716 gen = unur_init(par);
4717 if (gen) unur_tdr_chg_verify(gen,1);
4718 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[8],'~')==UNUR_SUCCESS)?0:1000;
4719 unur_free(gen);
4720
4721 unur_distr_free(distr_localcopy);
4722 } while (0);
4723 }
4724
4725 if(TRUE) {
4726 unur_reset_errno();
4727 do {
4728 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[8]);
4729 par = unur_tdr_new(distr_localcopy);
4730 unur_tdr_set_pedantic(par,0);
4731 unur_tdr_set_variant_ia(par);
4732 unur_tdr_set_c(par,-0.5);
4733 unur_tdr_set_usedars(par,FALSE);
4734 unur_tdr_set_cpoints(par,10,NULL);
4735 unur_tdr_set_max_sqhratio(par,0.25);
4736 gen = unur_init(par);
4737 if (gen) unur_tdr_chg_verify(gen,1);
4738 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[8],'~')==UNUR_SUCCESS)?0:1000;
4739 unur_free(gen);
4740
4741 unur_distr_free(distr_localcopy);
4742 } while (0);
4743 }
4744
4745 if(TRUE) {
4746 unur_reset_errno();
4747 do {
4748 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[8]);
4749 par = unur_tdr_new(distr_localcopy);
4750 unur_tdr_set_pedantic(par,0);
4751 unur_tdr_set_variant_ia(par);
4752 unur_tdr_set_c(par,0.);
4753 gen = unur_init(par);
4754 if (gen) unur_tdr_chg_verify(gen,1);
4755 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[8],'0')==UNUR_SUCCESS)?0:1000;
4756 unur_free(gen);
4757
4758 unur_distr_free(distr_localcopy);
4759 } while (0);
4760 }
4761
4762 if(TRUE) {
4763 unur_reset_errno();
4764 do {
4765 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[8]);
4766 par = unur_tdr_new(distr_localcopy);
4767 unur_tdr_set_pedantic(par,0);
4768 unur_tdr_set_variant_ia(par);
4769 unur_tdr_set_c(par,-0.5);
4770 unur_tdr_set_cpoints(par,30,NULL);
4771 unur_set_use_distr_privatecopy(par,FALSE);
4772 fpm[0] = 1.;
4773 fpm[1] = 4.;
4774 unur_distr_cont_set_pdfparams(distr_localcopy,fpm,2);
4775 gen = unur_init(par);
4776 if (gen) {
4777 unur_tdr_chg_reinit_percentiles(gen, 2, NULL );
4778 unur_reinit(gen);
4779 }
4780 if (gen) unur_tdr_chg_verify(gen,1);
4781 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[8],'~')==UNUR_SUCCESS)?0:1000;
4782 unur_free(gen);
4783
4784 unur_distr_free(distr_localcopy);
4785 } while (0);
4786 }
4787
4788 if(TRUE) {
4789 unur_reset_errno();
4790 do {
4791 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[8]);
4792 par = unur_tdr_new(distr_localcopy);
4793 unur_tdr_set_pedantic(par,0);
4794 unur_tdr_set_variant_ia(par);
4795 unur_tdr_set_c(par,0.);
4796 unur_tdr_set_cpoints(par,30,NULL);
4797 unur_set_use_distr_privatecopy(par,FALSE);
4798 fpm[0] = 1.;
4799 fpm[1] = 4.;
4800 unur_distr_cont_set_pdfparams(distr_localcopy,fpm,2);
4801 gen = unur_init(par);
4802 if (gen) {
4803 unur_tdr_chg_reinit_percentiles(gen, 2, NULL );
4804 unur_reinit(gen);
4805 }
4806 if (gen) unur_tdr_chg_verify(gen,1);
4807 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[8],'0')==UNUR_SUCCESS)?0:1000;
4808 unur_free(gen);
4809
4810 unur_distr_free(distr_localcopy);
4811 } while (0);
4812 }
4813
4814 /* distribution [24] */
4815
4816 if(TRUE) {
4817 unur_reset_errno();
4818 do {
4819 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[24]);
4820 par = unur_tdr_new(distr_localcopy);
4821 unur_tdr_set_pedantic(par,0);
4822 unur_tdr_set_variant_ia(par);
4823 unur_tdr_set_c(par,-0.5);
4824 gen = unur_init(par);
4825 if (gen) unur_tdr_chg_verify(gen,1);
4826 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[24],'~')==UNUR_SUCCESS)?0:1000;
4827 unur_free(gen);
4828
4829 unur_distr_free(distr_localcopy);
4830 } while (0);
4831 }
4832
4833 if(TRUE) {
4834 unur_reset_errno();
4835 do {
4836 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[24]);
4837 par = unur_tdr_new(distr_localcopy);
4838 unur_tdr_set_pedantic(par,0);
4839 unur_tdr_set_variant_ia(par);
4840 unur_tdr_set_c(par,-0.5);
4841 unur_tdr_set_usedars(par,FALSE);
4842 unur_tdr_set_cpoints(par,10,NULL);
4843 gen = unur_init(par);
4844 if (gen) unur_tdr_chg_verify(gen,1);
4845 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[24],'~')==UNUR_SUCCESS)?0:1000;
4846 unur_free(gen);
4847
4848 unur_distr_free(distr_localcopy);
4849 } while (0);
4850 }
4851
4852 if(TRUE) {
4853 unur_reset_errno();
4854 do {
4855 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[24]);
4856 par = unur_tdr_new(distr_localcopy);
4857 unur_tdr_set_pedantic(par,0);
4858 unur_tdr_set_variant_ia(par);
4859 unur_tdr_set_c(par,-0.5);
4860 unur_tdr_set_usedars(par,FALSE);
4861 unur_tdr_set_cpoints(par,10,NULL);
4862 unur_tdr_set_max_sqhratio(par,0.25);
4863 gen = unur_init(par);
4864 if (gen) unur_tdr_chg_verify(gen,1);
4865 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[24],'~')==UNUR_SUCCESS)?0:1000;
4866 unur_free(gen);
4867
4868 unur_distr_free(distr_localcopy);
4869 } while (0);
4870 }
4871
4872 if(TRUE) {
4873 unur_reset_errno();
4874 do {
4875 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[24]);
4876 par = unur_tdr_new(distr_localcopy);
4877 unur_tdr_set_pedantic(par,0);
4878 unur_tdr_set_variant_ia(par);
4879 unur_tdr_set_c(par,0.);
4880 gen = unur_init(par);
4881 if (gen) unur_tdr_chg_verify(gen,1);
4882 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[24],'~')==UNUR_SUCCESS)?0:1000;
4883 unur_free(gen);
4884
4885 unur_distr_free(distr_localcopy);
4886 } while (0);
4887 }
4888
4889 if(TRUE) {
4890 unur_reset_errno();
4891 do {
4892 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[24]);
4893 par = unur_tdr_new(distr_localcopy);
4894 unur_tdr_set_pedantic(par,0);
4895 unur_tdr_set_variant_ia(par);
4896 unur_tdr_set_c(par,-0.5);
4897 unur_tdr_set_cpoints(par,30,NULL);
4898 unur_set_use_distr_privatecopy(par,FALSE);
4899 fpm[0] = 1.;
4900 fpm[1] = 4.;
4901 unur_distr_cont_set_pdfparams(distr_localcopy,fpm,2);
4902 gen = unur_init(par);
4903 if (gen) {
4904 unur_tdr_chg_reinit_percentiles(gen, 2, NULL );
4905 unur_reinit(gen);
4906 }
4907 if (gen) unur_tdr_chg_verify(gen,1);
4908 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[24],'~')==UNUR_SUCCESS)?0:1000;
4909 unur_free(gen);
4910
4911 unur_distr_free(distr_localcopy);
4912 } while (0);
4913 }
4914
4915 if(TRUE) {
4916 unur_reset_errno();
4917 do {
4918 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[24]);
4919 par = unur_tdr_new(distr_localcopy);
4920 unur_tdr_set_pedantic(par,0);
4921 unur_tdr_set_variant_ia(par);
4922 unur_tdr_set_c(par,0.);
4923 unur_tdr_set_cpoints(par,30,NULL);
4924 unur_set_use_distr_privatecopy(par,FALSE);
4925 fpm[0] = 1.;
4926 fpm[1] = 4.;
4927 unur_distr_cont_set_pdfparams(distr_localcopy,fpm,2);
4928 gen = unur_init(par);
4929 if (gen) {
4930 unur_tdr_chg_reinit_percentiles(gen, 2, NULL );
4931 unur_reinit(gen);
4932 }
4933 if (gen) unur_tdr_chg_verify(gen,1);
4934 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[24],'~')==UNUR_SUCCESS)?0:1000;
4935 unur_free(gen);
4936
4937 unur_distr_free(distr_localcopy);
4938 } while (0);
4939 }
4940
4941 /* distribution [25] */
4942
4943 if(TRUE) {
4944 unur_reset_errno();
4945 do {
4946 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[25]);
4947 par = unur_tdr_new(distr_localcopy);
4948 unur_tdr_set_pedantic(par,0);
4949 unur_tdr_set_variant_ia(par);
4950 unur_tdr_set_c(par,-0.5);
4951 gen = unur_init(par);
4952 if (gen) unur_tdr_chg_verify(gen,1);
4953 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[25],'~')==UNUR_SUCCESS)?0:1000;
4954 unur_free(gen);
4955
4956 unur_distr_free(distr_localcopy);
4957 } while (0);
4958 }
4959
4960 if(TRUE) {
4961 unur_reset_errno();
4962 do {
4963 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[25]);
4964 par = unur_tdr_new(distr_localcopy);
4965 unur_tdr_set_pedantic(par,0);
4966 unur_tdr_set_variant_ia(par);
4967 unur_tdr_set_c(par,-0.5);
4968 unur_tdr_set_usedars(par,FALSE);
4969 unur_tdr_set_cpoints(par,10,NULL);
4970 gen = unur_init(par);
4971 if (gen) unur_tdr_chg_verify(gen,1);
4972 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[25],'~')==UNUR_SUCCESS)?0:1000;
4973 unur_free(gen);
4974
4975 unur_distr_free(distr_localcopy);
4976 } while (0);
4977 }
4978
4979 if(TRUE) {
4980 unur_reset_errno();
4981 do {
4982 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[25]);
4983 par = unur_tdr_new(distr_localcopy);
4984 unur_tdr_set_pedantic(par,0);
4985 unur_tdr_set_variant_ia(par);
4986 unur_tdr_set_c(par,-0.5);
4987 unur_tdr_set_usedars(par,FALSE);
4988 unur_tdr_set_cpoints(par,10,NULL);
4989 unur_tdr_set_max_sqhratio(par,0.25);
4990 gen = unur_init(par);
4991 if (gen) unur_tdr_chg_verify(gen,1);
4992 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[25],'~')==UNUR_SUCCESS)?0:1000;
4993 unur_free(gen);
4994
4995 unur_distr_free(distr_localcopy);
4996 } while (0);
4997 }
4998
4999 if(TRUE) {
5000 unur_reset_errno();
5001 do {
5002 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[25]);
5003 par = unur_tdr_new(distr_localcopy);
5004 unur_tdr_set_pedantic(par,0);
5005 unur_tdr_set_variant_ia(par);
5006 unur_tdr_set_c(par,0.);
5007 gen = unur_init(par);
5008 if (gen) unur_tdr_chg_verify(gen,1);
5009 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[25],'~')==UNUR_SUCCESS)?0:1000;
5010 unur_free(gen);
5011
5012 unur_distr_free(distr_localcopy);
5013 } while (0);
5014 }
5015
5016 if(TRUE) {
5017 unur_reset_errno();
5018 do {
5019 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[25]);
5020 par = unur_tdr_new(distr_localcopy);
5021 unur_tdr_set_pedantic(par,0);
5022 unur_tdr_set_variant_ia(par);
5023 unur_tdr_set_c(par,-0.5);
5024 unur_tdr_set_cpoints(par,30,NULL);
5025 unur_set_use_distr_privatecopy(par,FALSE);
5026 fpm[0] = 1.;
5027 fpm[1] = 4.;
5028 unur_distr_cont_set_pdfparams(distr_localcopy,fpm,2);
5029 gen = unur_init(par);
5030 if (gen) {
5031 unur_tdr_chg_reinit_percentiles(gen, 2, NULL );
5032 unur_reinit(gen);
5033 }
5034 if (gen) unur_tdr_chg_verify(gen,1);
5035 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[25],'~')==UNUR_SUCCESS)?0:1000;
5036 unur_free(gen);
5037
5038 unur_distr_free(distr_localcopy);
5039 } while (0);
5040 }
5041
5042 if(TRUE) {
5043 unur_reset_errno();
5044 do {
5045 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[25]);
5046 par = unur_tdr_new(distr_localcopy);
5047 unur_tdr_set_pedantic(par,0);
5048 unur_tdr_set_variant_ia(par);
5049 unur_tdr_set_c(par,0.);
5050 unur_tdr_set_cpoints(par,30,NULL);
5051 unur_set_use_distr_privatecopy(par,FALSE);
5052 fpm[0] = 1.;
5053 fpm[1] = 4.;
5054 unur_distr_cont_set_pdfparams(distr_localcopy,fpm,2);
5055 gen = unur_init(par);
5056 if (gen) {
5057 unur_tdr_chg_reinit_percentiles(gen, 2, NULL );
5058 unur_reinit(gen);
5059 }
5060 if (gen) unur_tdr_chg_verify(gen,1);
5061 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[25],'~')==UNUR_SUCCESS)?0:1000;
5062 unur_free(gen);
5063
5064 unur_distr_free(distr_localcopy);
5065 } while (0);
5066 }
5067
5068 /* distribution [9] */
5069
5070 if(fullcheck) {
5071 unur_reset_errno();
5072 do {
5073 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[9]);
5074 par = unur_tdr_new(distr_localcopy);
5075 unur_tdr_set_pedantic(par,0);
5076 unur_tdr_set_variant_ia(par);
5077 unur_tdr_set_c(par,-0.5);
5078 gen = unur_init(par);
5079 if (gen) unur_tdr_chg_verify(gen,1);
5080 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[9],'~')==UNUR_SUCCESS)?0:1000;
5081 unur_free(gen);
5082
5083 unur_distr_free(distr_localcopy);
5084 } while (0);
5085 }
5086
5087 if(fullcheck) {
5088 unur_reset_errno();
5089 do {
5090 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[9]);
5091 par = unur_tdr_new(distr_localcopy);
5092 unur_tdr_set_pedantic(par,0);
5093 unur_tdr_set_variant_ia(par);
5094 unur_tdr_set_c(par,-0.5);
5095 unur_tdr_set_usedars(par,FALSE);
5096 unur_tdr_set_cpoints(par,10,NULL);
5097 gen = unur_init(par);
5098 if (gen) unur_tdr_chg_verify(gen,1);
5099 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[9],'~')==UNUR_SUCCESS)?0:1000;
5100 unur_free(gen);
5101
5102 unur_distr_free(distr_localcopy);
5103 } while (0);
5104 }
5105
5106 if(fullcheck) {
5107 unur_reset_errno();
5108 do {
5109 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[9]);
5110 par = unur_tdr_new(distr_localcopy);
5111 unur_tdr_set_pedantic(par,0);
5112 unur_tdr_set_variant_ia(par);
5113 unur_tdr_set_c(par,-0.5);
5114 unur_tdr_set_usedars(par,FALSE);
5115 unur_tdr_set_cpoints(par,10,NULL);
5116 unur_tdr_set_max_sqhratio(par,0.25);
5117 gen = unur_init(par);
5118 if (gen) unur_tdr_chg_verify(gen,1);
5119 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[9],'~')==UNUR_SUCCESS)?0:1000;
5120 unur_free(gen);
5121
5122 unur_distr_free(distr_localcopy);
5123 } while (0);
5124 }
5125
5126 if(fullcheck) {
5127 unur_reset_errno();
5128 do {
5129 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[9]);
5130 par = unur_tdr_new(distr_localcopy);
5131 unur_tdr_set_pedantic(par,0);
5132 unur_tdr_set_variant_ia(par);
5133 unur_tdr_set_c(par,0.);
5134 gen = unur_init(par);
5135 if (gen) unur_tdr_chg_verify(gen,1);
5136 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[9],'~')==UNUR_SUCCESS)?0:1000;
5137 unur_free(gen);
5138
5139 unur_distr_free(distr_localcopy);
5140 } while (0);
5141 }
5142
5143 if(fullcheck) {
5144 printf("."); fflush(stdout);
5145 }
5146
5147 if(fullcheck) {
5148 printf("."); fflush(stdout);
5149 }
5150
5151 /* distribution [10] */
5152
5153 if(TRUE) {
5154 unur_reset_errno();
5155 do {
5156 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[10]);
5157 par = unur_tdr_new(distr_localcopy);
5158 unur_tdr_set_pedantic(par,0);
5159 unur_tdr_set_variant_ia(par);
5160 unur_tdr_set_c(par,-0.5);
5161 gen = unur_init(par);
5162 if (gen) unur_tdr_chg_verify(gen,1);
5163 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[10],'~')==UNUR_SUCCESS)?0:1000;
5164 unur_free(gen);
5165
5166 unur_distr_free(distr_localcopy);
5167 } while (0);
5168 }
5169
5170 if(TRUE) {
5171 unur_reset_errno();
5172 do {
5173 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[10]);
5174 par = unur_tdr_new(distr_localcopy);
5175 unur_tdr_set_pedantic(par,0);
5176 unur_tdr_set_variant_ia(par);
5177 unur_tdr_set_c(par,-0.5);
5178 unur_tdr_set_usedars(par,FALSE);
5179 unur_tdr_set_cpoints(par,10,NULL);
5180 gen = unur_init(par);
5181 if (gen) unur_tdr_chg_verify(gen,1);
5182 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[10],'~')==UNUR_SUCCESS)?0:1000;
5183 unur_free(gen);
5184
5185 unur_distr_free(distr_localcopy);
5186 } while (0);
5187 }
5188
5189 if(TRUE) {
5190 unur_reset_errno();
5191 do {
5192 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[10]);
5193 par = unur_tdr_new(distr_localcopy);
5194 unur_tdr_set_pedantic(par,0);
5195 unur_tdr_set_variant_ia(par);
5196 unur_tdr_set_c(par,-0.5);
5197 unur_tdr_set_usedars(par,FALSE);
5198 unur_tdr_set_cpoints(par,10,NULL);
5199 unur_tdr_set_max_sqhratio(par,0.25);
5200 gen = unur_init(par);
5201 if (gen) unur_tdr_chg_verify(gen,1);
5202 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[10],'~')==UNUR_SUCCESS)?0:1000;
5203 unur_free(gen);
5204
5205 unur_distr_free(distr_localcopy);
5206 } while (0);
5207 }
5208
5209 if(TRUE) {
5210 unur_reset_errno();
5211 do {
5212 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[10]);
5213 par = unur_tdr_new(distr_localcopy);
5214 unur_tdr_set_pedantic(par,0);
5215 unur_tdr_set_variant_ia(par);
5216 unur_tdr_set_c(par,0.);
5217 gen = unur_init(par);
5218 if (gen) unur_tdr_chg_verify(gen,1);
5219 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[10],'~')==UNUR_SUCCESS)?0:1000;
5220 unur_free(gen);
5221
5222 unur_distr_free(distr_localcopy);
5223 } while (0);
5224 }
5225
5226 if(TRUE) {
5227 printf("."); fflush(stdout);
5228 }
5229
5230 if(TRUE) {
5231 printf("."); fflush(stdout);
5232 }
5233
5234 /* distribution [11] */
5235
5236 if(TRUE) {
5237 unur_reset_errno();
5238 do {
5239 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[11]);
5240 par = unur_tdr_new(distr_localcopy);
5241 unur_tdr_set_pedantic(par,0);
5242 unur_tdr_set_variant_ia(par);
5243 unur_tdr_set_c(par,-0.5);
5244 gen = unur_init(par);
5245 if (gen) unur_tdr_chg_verify(gen,1);
5246 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[11],'~')==UNUR_SUCCESS)?0:1000;
5247 unur_free(gen);
5248
5249 unur_distr_free(distr_localcopy);
5250 } while (0);
5251 }
5252
5253 if(TRUE) {
5254 unur_reset_errno();
5255 do {
5256 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[11]);
5257 par = unur_tdr_new(distr_localcopy);
5258 unur_tdr_set_pedantic(par,0);
5259 unur_tdr_set_variant_ia(par);
5260 unur_tdr_set_c(par,-0.5);
5261 unur_tdr_set_usedars(par,FALSE);
5262 unur_tdr_set_cpoints(par,10,NULL);
5263 gen = unur_init(par);
5264 if (gen) unur_tdr_chg_verify(gen,1);
5265 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[11],'~')==UNUR_SUCCESS)?0:1000;
5266 unur_free(gen);
5267
5268 unur_distr_free(distr_localcopy);
5269 } while (0);
5270 }
5271
5272 if(TRUE) {
5273 unur_reset_errno();
5274 do {
5275 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[11]);
5276 par = unur_tdr_new(distr_localcopy);
5277 unur_tdr_set_pedantic(par,0);
5278 unur_tdr_set_variant_ia(par);
5279 unur_tdr_set_c(par,-0.5);
5280 unur_tdr_set_usedars(par,FALSE);
5281 unur_tdr_set_cpoints(par,10,NULL);
5282 unur_tdr_set_max_sqhratio(par,0.25);
5283 gen = unur_init(par);
5284 if (gen) unur_tdr_chg_verify(gen,1);
5285 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[11],'~')==UNUR_SUCCESS)?0:1000;
5286 unur_free(gen);
5287
5288 unur_distr_free(distr_localcopy);
5289 } while (0);
5290 }
5291
5292 if(TRUE) {
5293 unur_reset_errno();
5294 do {
5295 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[11]);
5296 par = unur_tdr_new(distr_localcopy);
5297 unur_tdr_set_pedantic(par,0);
5298 unur_tdr_set_variant_ia(par);
5299 unur_tdr_set_c(par,0.);
5300 gen = unur_init(par);
5301 if (gen) unur_tdr_chg_verify(gen,1);
5302 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[11],'~')==UNUR_SUCCESS)?0:1000;
5303 unur_free(gen);
5304
5305 unur_distr_free(distr_localcopy);
5306 } while (0);
5307 }
5308
5309 if(TRUE) {
5310 unur_reset_errno();
5311 do {
5312 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[11]);
5313 par = unur_tdr_new(distr_localcopy);
5314 unur_tdr_set_pedantic(par,0);
5315 unur_tdr_set_variant_ia(par);
5316 unur_tdr_set_c(par,-0.5);
5317 unur_tdr_set_cpoints(par,30,NULL);
5318 unur_set_use_distr_privatecopy(par,FALSE);
5319 fpm[0] = 1.;
5320 fpm[1] = 4.;
5321 unur_distr_cont_set_pdfparams(distr_localcopy,fpm,2);
5322 gen = unur_init(par);
5323 if (gen) {
5324 unur_tdr_chg_reinit_percentiles(gen, 2, NULL );
5325 unur_reinit(gen);
5326 }
5327 if (gen) unur_tdr_chg_verify(gen,1);
5328 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[11],'~')==UNUR_SUCCESS)?0:1000;
5329 unur_free(gen);
5330
5331 unur_distr_free(distr_localcopy);
5332 } while (0);
5333 }
5334
5335 if(TRUE) {
5336 unur_reset_errno();
5337 do {
5338 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[11]);
5339 par = unur_tdr_new(distr_localcopy);
5340 unur_tdr_set_pedantic(par,0);
5341 unur_tdr_set_variant_ia(par);
5342 unur_tdr_set_c(par,0.);
5343 unur_tdr_set_cpoints(par,30,NULL);
5344 unur_set_use_distr_privatecopy(par,FALSE);
5345 fpm[0] = 1.;
5346 fpm[1] = 4.;
5347 unur_distr_cont_set_pdfparams(distr_localcopy,fpm,2);
5348 gen = unur_init(par);
5349 if (gen) {
5350 unur_tdr_chg_reinit_percentiles(gen, 2, NULL );
5351 unur_reinit(gen);
5352 }
5353 if (gen) unur_tdr_chg_verify(gen,1);
5354 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[11],'~')==UNUR_SUCCESS)?0:1000;
5355 unur_free(gen);
5356
5357 unur_distr_free(distr_localcopy);
5358 } while (0);
5359 }
5360
5361 /* distribution [12] */
5362
5363 if(TRUE) {
5364 unur_reset_errno();
5365 do {
5366 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[12]);
5367 par = unur_tdr_new(distr_localcopy);
5368 unur_tdr_set_pedantic(par,0);
5369 unur_tdr_set_variant_ia(par);
5370 unur_tdr_set_c(par,-0.5);
5371 gen = unur_init(par);
5372 if (gen) unur_tdr_chg_verify(gen,1);
5373 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[12],'~')==UNUR_SUCCESS)?0:1000;
5374 unur_free(gen);
5375
5376 unur_distr_free(distr_localcopy);
5377 } while (0);
5378 }
5379
5380 if(TRUE) {
5381 unur_reset_errno();
5382 do {
5383 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[12]);
5384 par = unur_tdr_new(distr_localcopy);
5385 unur_tdr_set_pedantic(par,0);
5386 unur_tdr_set_variant_ia(par);
5387 unur_tdr_set_c(par,-0.5);
5388 unur_tdr_set_usedars(par,FALSE);
5389 unur_tdr_set_cpoints(par,10,NULL);
5390 gen = unur_init(par);
5391 if (gen) unur_tdr_chg_verify(gen,1);
5392 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[12],'~')==UNUR_SUCCESS)?0:1000;
5393 unur_free(gen);
5394
5395 unur_distr_free(distr_localcopy);
5396 } while (0);
5397 }
5398
5399 if(TRUE) {
5400 unur_reset_errno();
5401 do {
5402 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[12]);
5403 par = unur_tdr_new(distr_localcopy);
5404 unur_tdr_set_pedantic(par,0);
5405 unur_tdr_set_variant_ia(par);
5406 unur_tdr_set_c(par,-0.5);
5407 unur_tdr_set_usedars(par,FALSE);
5408 unur_tdr_set_cpoints(par,10,NULL);
5409 unur_tdr_set_max_sqhratio(par,0.25);
5410 gen = unur_init(par);
5411 if (gen) unur_tdr_chg_verify(gen,1);
5412 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[12],'~')==UNUR_SUCCESS)?0:1000;
5413 unur_free(gen);
5414
5415 unur_distr_free(distr_localcopy);
5416 } while (0);
5417 }
5418
5419 if(TRUE) {
5420 unur_reset_errno();
5421 do {
5422 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[12]);
5423 par = unur_tdr_new(distr_localcopy);
5424 unur_tdr_set_pedantic(par,0);
5425 unur_tdr_set_variant_ia(par);
5426 unur_tdr_set_c(par,0.);
5427 gen = unur_init(par);
5428 if (gen) unur_tdr_chg_verify(gen,1);
5429 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[12],'~')==UNUR_SUCCESS)?0:1000;
5430 unur_free(gen);
5431
5432 unur_distr_free(distr_localcopy);
5433 } while (0);
5434 }
5435
5436 if(TRUE) {
5437 printf("."); fflush(stdout);
5438 }
5439
5440 if(TRUE) {
5441 printf("."); fflush(stdout);
5442 }
5443
5444 /* distribution [13] */
5445
5446 if(fullcheck) {
5447 unur_reset_errno();
5448 do {
5449 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[13]);
5450 par = unur_tdr_new(distr_localcopy);
5451 unur_tdr_set_pedantic(par,0);
5452 unur_tdr_set_variant_ia(par);
5453 unur_tdr_set_c(par,-0.5);
5454 gen = unur_init(par);
5455 if (gen) unur_tdr_chg_verify(gen,1);
5456 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[13],'~')==UNUR_SUCCESS)?0:1000;
5457 unur_free(gen);
5458
5459 unur_distr_free(distr_localcopy);
5460 } while (0);
5461 }
5462
5463 if(fullcheck) {
5464 unur_reset_errno();
5465 do {
5466 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[13]);
5467 par = unur_tdr_new(distr_localcopy);
5468 unur_tdr_set_pedantic(par,0);
5469 unur_tdr_set_variant_ia(par);
5470 unur_tdr_set_c(par,-0.5);
5471 unur_tdr_set_usedars(par,FALSE);
5472 unur_tdr_set_cpoints(par,10,NULL);
5473 gen = unur_init(par);
5474 if (gen) unur_tdr_chg_verify(gen,1);
5475 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[13],'~')==UNUR_SUCCESS)?0:1000;
5476 unur_free(gen);
5477
5478 unur_distr_free(distr_localcopy);
5479 } while (0);
5480 }
5481
5482 if(fullcheck) {
5483 unur_reset_errno();
5484 do {
5485 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[13]);
5486 par = unur_tdr_new(distr_localcopy);
5487 unur_tdr_set_pedantic(par,0);
5488 unur_tdr_set_variant_ia(par);
5489 unur_tdr_set_c(par,-0.5);
5490 unur_tdr_set_usedars(par,FALSE);
5491 unur_tdr_set_cpoints(par,10,NULL);
5492 unur_tdr_set_max_sqhratio(par,0.25);
5493 gen = unur_init(par);
5494 if (gen) unur_tdr_chg_verify(gen,1);
5495 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[13],'~')==UNUR_SUCCESS)?0:1000;
5496 unur_free(gen);
5497
5498 unur_distr_free(distr_localcopy);
5499 } while (0);
5500 }
5501
5502 if(fullcheck) {
5503 unur_reset_errno();
5504 do {
5505 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[13]);
5506 par = unur_tdr_new(distr_localcopy);
5507 unur_tdr_set_pedantic(par,0);
5508 unur_tdr_set_variant_ia(par);
5509 unur_tdr_set_c(par,0.);
5510 gen = unur_init(par);
5511 if (gen) unur_tdr_chg_verify(gen,1);
5512 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[13],'~')==UNUR_SUCCESS)?0:1000;
5513 unur_free(gen);
5514
5515 unur_distr_free(distr_localcopy);
5516 } while (0);
5517 }
5518
5519 if(fullcheck) {
5520 printf("."); fflush(stdout);
5521 }
5522
5523 if(fullcheck) {
5524 printf("."); fflush(stdout);
5525 }
5526
5527 /* distribution [14] */
5528
5529 if(TRUE) {
5530 unur_reset_errno();
5531 do {
5532 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[14]);
5533 par = unur_tdr_new(distr_localcopy);
5534 unur_tdr_set_pedantic(par,0);
5535 unur_tdr_set_variant_ia(par);
5536 unur_tdr_set_c(par,-0.5);
5537 gen = unur_init(par);
5538 if (gen) unur_tdr_chg_verify(gen,1);
5539 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[14],'~')==UNUR_SUCCESS)?0:1000;
5540 unur_free(gen);
5541
5542 unur_distr_free(distr_localcopy);
5543 } while (0);
5544 }
5545
5546 if(TRUE) {
5547 unur_reset_errno();
5548 do {
5549 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[14]);
5550 par = unur_tdr_new(distr_localcopy);
5551 unur_tdr_set_pedantic(par,0);
5552 unur_tdr_set_variant_ia(par);
5553 unur_tdr_set_c(par,-0.5);
5554 unur_tdr_set_usedars(par,FALSE);
5555 unur_tdr_set_cpoints(par,10,NULL);
5556 gen = unur_init(par);
5557 if (gen) unur_tdr_chg_verify(gen,1);
5558 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[14],'~')==UNUR_SUCCESS)?0:1000;
5559 unur_free(gen);
5560
5561 unur_distr_free(distr_localcopy);
5562 } while (0);
5563 }
5564
5565 if(TRUE) {
5566 unur_reset_errno();
5567 do {
5568 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[14]);
5569 par = unur_tdr_new(distr_localcopy);
5570 unur_tdr_set_pedantic(par,0);
5571 unur_tdr_set_variant_ia(par);
5572 unur_tdr_set_c(par,-0.5);
5573 unur_tdr_set_usedars(par,FALSE);
5574 unur_tdr_set_cpoints(par,10,NULL);
5575 unur_tdr_set_max_sqhratio(par,0.25);
5576 gen = unur_init(par);
5577 if (gen) unur_tdr_chg_verify(gen,1);
5578 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[14],'~')==UNUR_SUCCESS)?0:1000;
5579 unur_free(gen);
5580
5581 unur_distr_free(distr_localcopy);
5582 } while (0);
5583 }
5584
5585 if(TRUE) {
5586 unur_reset_errno();
5587 do {
5588 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[14]);
5589 par = unur_tdr_new(distr_localcopy);
5590 unur_tdr_set_pedantic(par,0);
5591 unur_tdr_set_variant_ia(par);
5592 unur_tdr_set_c(par,0.);
5593 gen = unur_init(par);
5594 if (gen) unur_tdr_chg_verify(gen,1);
5595 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[14],'~')==UNUR_SUCCESS)?0:1000;
5596 unur_free(gen);
5597
5598 unur_distr_free(distr_localcopy);
5599 } while (0);
5600 }
5601
5602 if(TRUE) {
5603 printf("."); fflush(stdout);
5604 }
5605
5606 if(TRUE) {
5607 printf("."); fflush(stdout);
5608 }
5609
5610 /* distribution [15] */
5611
5612 if(fullcheck) {
5613 unur_reset_errno();
5614 do {
5615 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[15]);
5616 par = unur_tdr_new(distr_localcopy);
5617 unur_tdr_set_pedantic(par,0);
5618 unur_tdr_set_variant_ia(par);
5619 unur_tdr_set_c(par,-0.5);
5620 gen = unur_init(par);
5621 if (gen) unur_tdr_chg_verify(gen,1);
5622 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[15],'~')==UNUR_SUCCESS)?0:1000;
5623 unur_free(gen);
5624
5625 unur_distr_free(distr_localcopy);
5626 } while (0);
5627 }
5628
5629 if(fullcheck) {
5630 unur_reset_errno();
5631 do {
5632 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[15]);
5633 par = unur_tdr_new(distr_localcopy);
5634 unur_tdr_set_pedantic(par,0);
5635 unur_tdr_set_variant_ia(par);
5636 unur_tdr_set_c(par,-0.5);
5637 unur_tdr_set_usedars(par,FALSE);
5638 unur_tdr_set_cpoints(par,10,NULL);
5639 gen = unur_init(par);
5640 if (gen) unur_tdr_chg_verify(gen,1);
5641 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[15],'~')==UNUR_SUCCESS)?0:1000;
5642 unur_free(gen);
5643
5644 unur_distr_free(distr_localcopy);
5645 } while (0);
5646 }
5647
5648 if(fullcheck) {
5649 unur_reset_errno();
5650 do {
5651 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[15]);
5652 par = unur_tdr_new(distr_localcopy);
5653 unur_tdr_set_pedantic(par,0);
5654 unur_tdr_set_variant_ia(par);
5655 unur_tdr_set_c(par,-0.5);
5656 unur_tdr_set_usedars(par,FALSE);
5657 unur_tdr_set_cpoints(par,10,NULL);
5658 unur_tdr_set_max_sqhratio(par,0.25);
5659 gen = unur_init(par);
5660 if (gen) unur_tdr_chg_verify(gen,1);
5661 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[15],'~')==UNUR_SUCCESS)?0:1000;
5662 unur_free(gen);
5663
5664 unur_distr_free(distr_localcopy);
5665 } while (0);
5666 }
5667
5668 if(fullcheck) {
5669 unur_reset_errno();
5670 do {
5671 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[15]);
5672 par = unur_tdr_new(distr_localcopy);
5673 unur_tdr_set_pedantic(par,0);
5674 unur_tdr_set_variant_ia(par);
5675 unur_tdr_set_c(par,0.);
5676 gen = unur_init(par);
5677 if (gen) unur_tdr_chg_verify(gen,1);
5678 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[15],'~')==UNUR_SUCCESS)?0:1000;
5679 unur_free(gen);
5680
5681 unur_distr_free(distr_localcopy);
5682 } while (0);
5683 }
5684
5685 if(fullcheck) {
5686 printf("."); fflush(stdout);
5687 }
5688
5689 if(fullcheck) {
5690 printf("."); fflush(stdout);
5691 }
5692
5693 /* distribution [16] */
5694
5695 if(fullcheck) {
5696 unur_reset_errno();
5697 do {
5698 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[16]);
5699 par = unur_tdr_new(distr_localcopy);
5700 unur_tdr_set_pedantic(par,0);
5701 unur_tdr_set_variant_ia(par);
5702 unur_tdr_set_c(par,-0.5);
5703 gen = unur_init(par);
5704 if (gen) unur_tdr_chg_verify(gen,1);
5705 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[16],'~')==UNUR_SUCCESS)?0:1000;
5706 unur_free(gen);
5707
5708 unur_distr_free(distr_localcopy);
5709 } while (0);
5710 }
5711
5712 if(fullcheck) {
5713 unur_reset_errno();
5714 do {
5715 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[16]);
5716 par = unur_tdr_new(distr_localcopy);
5717 unur_tdr_set_pedantic(par,0);
5718 unur_tdr_set_variant_ia(par);
5719 unur_tdr_set_c(par,-0.5);
5720 unur_tdr_set_usedars(par,FALSE);
5721 unur_tdr_set_cpoints(par,10,NULL);
5722 gen = unur_init(par);
5723 if (gen) unur_tdr_chg_verify(gen,1);
5724 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[16],'~')==UNUR_SUCCESS)?0:1000;
5725 unur_free(gen);
5726
5727 unur_distr_free(distr_localcopy);
5728 } while (0);
5729 }
5730
5731 if(fullcheck) {
5732 unur_reset_errno();
5733 do {
5734 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[16]);
5735 par = unur_tdr_new(distr_localcopy);
5736 unur_tdr_set_pedantic(par,0);
5737 unur_tdr_set_variant_ia(par);
5738 unur_tdr_set_c(par,-0.5);
5739 unur_tdr_set_usedars(par,FALSE);
5740 unur_tdr_set_cpoints(par,10,NULL);
5741 unur_tdr_set_max_sqhratio(par,0.25);
5742 gen = unur_init(par);
5743 if (gen) unur_tdr_chg_verify(gen,1);
5744 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[16],'~')==UNUR_SUCCESS)?0:1000;
5745 unur_free(gen);
5746
5747 unur_distr_free(distr_localcopy);
5748 } while (0);
5749 }
5750
5751 if(fullcheck) {
5752 unur_reset_errno();
5753 do {
5754 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[16]);
5755 par = unur_tdr_new(distr_localcopy);
5756 unur_tdr_set_pedantic(par,0);
5757 unur_tdr_set_variant_ia(par);
5758 unur_tdr_set_c(par,0.);
5759 gen = unur_init(par);
5760 if (gen) unur_tdr_chg_verify(gen,1);
5761 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[16],'~')==UNUR_SUCCESS)?0:1000;
5762 unur_free(gen);
5763
5764 unur_distr_free(distr_localcopy);
5765 } while (0);
5766 }
5767
5768 if(fullcheck) {
5769 printf("."); fflush(stdout);
5770 }
5771
5772 if(fullcheck) {
5773 printf("."); fflush(stdout);
5774 }
5775
5776 /* distribution [26] */
5777
5778 if(TRUE) {
5779 unur_reset_errno();
5780 do {
5781 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[26]);
5782 par = unur_tdr_new(distr_localcopy);
5783 unur_tdr_set_pedantic(par,0);
5784 unur_tdr_set_variant_ia(par);
5785 unur_tdr_set_c(par,-0.5);
5786 gen = unur_init(par);
5787 if (gen) unur_tdr_chg_verify(gen,1);
5788 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[26],'~')==UNUR_SUCCESS)?0:1000;
5789 unur_free(gen);
5790
5791 unur_distr_free(distr_localcopy);
5792 } while (0);
5793 }
5794
5795 if(TRUE) {
5796 unur_reset_errno();
5797 do {
5798 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[26]);
5799 par = unur_tdr_new(distr_localcopy);
5800 unur_tdr_set_pedantic(par,0);
5801 unur_tdr_set_variant_ia(par);
5802 unur_tdr_set_c(par,-0.5);
5803 unur_tdr_set_usedars(par,FALSE);
5804 unur_tdr_set_cpoints(par,10,NULL);
5805 gen = unur_init(par);
5806 if (gen) unur_tdr_chg_verify(gen,1);
5807 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[26],'~')==UNUR_SUCCESS)?0:1000;
5808 unur_free(gen);
5809
5810 unur_distr_free(distr_localcopy);
5811 } while (0);
5812 }
5813
5814 if(TRUE) {
5815 unur_reset_errno();
5816 do {
5817 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[26]);
5818 par = unur_tdr_new(distr_localcopy);
5819 unur_tdr_set_pedantic(par,0);
5820 unur_tdr_set_variant_ia(par);
5821 unur_tdr_set_c(par,-0.5);
5822 unur_tdr_set_usedars(par,FALSE);
5823 unur_tdr_set_cpoints(par,10,NULL);
5824 unur_tdr_set_max_sqhratio(par,0.25);
5825 gen = unur_init(par);
5826 if (gen) unur_tdr_chg_verify(gen,1);
5827 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[26],'~')==UNUR_SUCCESS)?0:1000;
5828 unur_free(gen);
5829
5830 unur_distr_free(distr_localcopy);
5831 } while (0);
5832 }
5833
5834 if(TRUE) {
5835 unur_reset_errno();
5836 do {
5837 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[26]);
5838 par = unur_tdr_new(distr_localcopy);
5839 unur_tdr_set_pedantic(par,0);
5840 unur_tdr_set_variant_ia(par);
5841 unur_tdr_set_c(par,0.);
5842 gen = unur_init(par);
5843 if (gen) unur_tdr_chg_verify(gen,1);
5844 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[26],'~')==UNUR_SUCCESS)?0:1000;
5845 unur_free(gen);
5846
5847 unur_distr_free(distr_localcopy);
5848 } while (0);
5849 }
5850
5851 if(TRUE) {
5852 unur_reset_errno();
5853 do {
5854 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[26]);
5855 par = unur_tdr_new(distr_localcopy);
5856 unur_tdr_set_pedantic(par,0);
5857 unur_tdr_set_variant_ia(par);
5858 unur_tdr_set_c(par,-0.5);
5859 unur_tdr_set_cpoints(par,30,NULL);
5860 unur_set_use_distr_privatecopy(par,FALSE);
5861 fpm[0] = 1.;
5862 fpm[1] = 4.;
5863 unur_distr_cont_set_pdfparams(distr_localcopy,fpm,2);
5864 gen = unur_init(par);
5865 if (gen) {
5866 unur_tdr_chg_reinit_percentiles(gen, 2, NULL );
5867 unur_reinit(gen);
5868 }
5869 if (gen) unur_tdr_chg_verify(gen,1);
5870 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[26],'~')==UNUR_SUCCESS)?0:1000;
5871 unur_free(gen);
5872
5873 unur_distr_free(distr_localcopy);
5874 } while (0);
5875 }
5876
5877 if(TRUE) {
5878 unur_reset_errno();
5879 do {
5880 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[26]);
5881 par = unur_tdr_new(distr_localcopy);
5882 unur_tdr_set_pedantic(par,0);
5883 unur_tdr_set_variant_ia(par);
5884 unur_tdr_set_c(par,0.);
5885 unur_tdr_set_cpoints(par,30,NULL);
5886 unur_set_use_distr_privatecopy(par,FALSE);
5887 fpm[0] = 1.;
5888 fpm[1] = 4.;
5889 unur_distr_cont_set_pdfparams(distr_localcopy,fpm,2);
5890 gen = unur_init(par);
5891 if (gen) {
5892 unur_tdr_chg_reinit_percentiles(gen, 2, NULL );
5893 unur_reinit(gen);
5894 }
5895 if (gen) unur_tdr_chg_verify(gen,1);
5896 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[26],'~')==UNUR_SUCCESS)?0:1000;
5897 unur_free(gen);
5898
5899 unur_distr_free(distr_localcopy);
5900 } while (0);
5901 }
5902
5903 /* distribution [27] */
5904
5905 if(TRUE) {
5906 unur_reset_errno();
5907 do {
5908 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[27]);
5909 par = unur_tdr_new(distr_localcopy);
5910 unur_tdr_set_pedantic(par,0);
5911 unur_tdr_set_variant_ia(par);
5912 unur_tdr_set_c(par,-0.5);
5913 gen = unur_init(par);
5914 if (gen) unur_tdr_chg_verify(gen,1);
5915 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[27],'~')==UNUR_SUCCESS)?0:1000;
5916 unur_free(gen);
5917
5918 unur_distr_free(distr_localcopy);
5919 } while (0);
5920 }
5921
5922 if(TRUE) {
5923 unur_reset_errno();
5924 do {
5925 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[27]);
5926 par = unur_tdr_new(distr_localcopy);
5927 unur_tdr_set_pedantic(par,0);
5928 unur_tdr_set_variant_ia(par);
5929 unur_tdr_set_c(par,-0.5);
5930 unur_tdr_set_usedars(par,FALSE);
5931 unur_tdr_set_cpoints(par,10,NULL);
5932 gen = unur_init(par);
5933 if (gen) unur_tdr_chg_verify(gen,1);
5934 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[27],'~')==UNUR_SUCCESS)?0:1000;
5935 unur_free(gen);
5936
5937 unur_distr_free(distr_localcopy);
5938 } while (0);
5939 }
5940
5941 if(TRUE) {
5942 unur_reset_errno();
5943 do {
5944 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[27]);
5945 par = unur_tdr_new(distr_localcopy);
5946 unur_tdr_set_pedantic(par,0);
5947 unur_tdr_set_variant_ia(par);
5948 unur_tdr_set_c(par,-0.5);
5949 unur_tdr_set_usedars(par,FALSE);
5950 unur_tdr_set_cpoints(par,10,NULL);
5951 unur_tdr_set_max_sqhratio(par,0.25);
5952 gen = unur_init(par);
5953 if (gen) unur_tdr_chg_verify(gen,1);
5954 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[27],'~')==UNUR_SUCCESS)?0:1000;
5955 unur_free(gen);
5956
5957 unur_distr_free(distr_localcopy);
5958 } while (0);
5959 }
5960
5961 if(TRUE) {
5962 unur_reset_errno();
5963 do {
5964 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[27]);
5965 par = unur_tdr_new(distr_localcopy);
5966 unur_tdr_set_pedantic(par,0);
5967 unur_tdr_set_variant_ia(par);
5968 unur_tdr_set_c(par,0.);
5969 gen = unur_init(par);
5970 if (gen) unur_tdr_chg_verify(gen,1);
5971 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[27],'~')==UNUR_SUCCESS)?0:1000;
5972 unur_free(gen);
5973
5974 unur_distr_free(distr_localcopy);
5975 } while (0);
5976 }
5977
5978 if(TRUE) {
5979 unur_reset_errno();
5980 do {
5981 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[27]);
5982 par = unur_tdr_new(distr_localcopy);
5983 unur_tdr_set_pedantic(par,0);
5984 unur_tdr_set_variant_ia(par);
5985 unur_tdr_set_c(par,-0.5);
5986 unur_tdr_set_cpoints(par,30,NULL);
5987 unur_set_use_distr_privatecopy(par,FALSE);
5988 fpm[0] = 1.;
5989 fpm[1] = 4.;
5990 unur_distr_cont_set_pdfparams(distr_localcopy,fpm,2);
5991 gen = unur_init(par);
5992 if (gen) {
5993 unur_tdr_chg_reinit_percentiles(gen, 2, NULL );
5994 unur_reinit(gen);
5995 }
5996 if (gen) unur_tdr_chg_verify(gen,1);
5997 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[27],'~')==UNUR_SUCCESS)?0:1000;
5998 unur_free(gen);
5999
6000 unur_distr_free(distr_localcopy);
6001 } while (0);
6002 }
6003
6004 if(TRUE) {
6005 unur_reset_errno();
6006 do {
6007 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[27]);
6008 par = unur_tdr_new(distr_localcopy);
6009 unur_tdr_set_pedantic(par,0);
6010 unur_tdr_set_variant_ia(par);
6011 unur_tdr_set_c(par,0.);
6012 unur_tdr_set_cpoints(par,30,NULL);
6013 unur_set_use_distr_privatecopy(par,FALSE);
6014 fpm[0] = 1.;
6015 fpm[1] = 4.;
6016 unur_distr_cont_set_pdfparams(distr_localcopy,fpm,2);
6017 gen = unur_init(par);
6018 if (gen) {
6019 unur_tdr_chg_reinit_percentiles(gen, 2, NULL );
6020 unur_reinit(gen);
6021 }
6022 if (gen) unur_tdr_chg_verify(gen,1);
6023 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[27],'~')==UNUR_SUCCESS)?0:1000;
6024 unur_free(gen);
6025
6026 unur_distr_free(distr_localcopy);
6027 } while (0);
6028 }
6029
6030 /* distribution [17] */
6031
6032 if(TRUE) {
6033 unur_reset_errno();
6034 do {
6035 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[17]);
6036 par = unur_tdr_new(distr_localcopy);
6037 unur_tdr_set_pedantic(par,0);
6038 unur_tdr_set_variant_ia(par);
6039 unur_tdr_set_c(par,-0.5);
6040 gen = unur_init(par);
6041 if (gen) unur_tdr_chg_verify(gen,1);
6042 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[17],'~')==UNUR_SUCCESS)?0:1000;
6043 unur_free(gen);
6044
6045 unur_distr_free(distr_localcopy);
6046 } while (0);
6047 }
6048
6049 if(TRUE) {
6050 unur_reset_errno();
6051 do {
6052 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[17]);
6053 par = unur_tdr_new(distr_localcopy);
6054 unur_tdr_set_pedantic(par,0);
6055 unur_tdr_set_variant_ia(par);
6056 unur_tdr_set_c(par,-0.5);
6057 unur_tdr_set_usedars(par,FALSE);
6058 unur_tdr_set_cpoints(par,10,NULL);
6059 gen = unur_init(par);
6060 if (gen) unur_tdr_chg_verify(gen,1);
6061 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[17],'~')==UNUR_SUCCESS)?0:1000;
6062 unur_free(gen);
6063
6064 unur_distr_free(distr_localcopy);
6065 } while (0);
6066 }
6067
6068 if(TRUE) {
6069 unur_reset_errno();
6070 do {
6071 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[17]);
6072 par = unur_tdr_new(distr_localcopy);
6073 unur_tdr_set_pedantic(par,0);
6074 unur_tdr_set_variant_ia(par);
6075 unur_tdr_set_c(par,-0.5);
6076 unur_tdr_set_usedars(par,FALSE);
6077 unur_tdr_set_cpoints(par,10,NULL);
6078 unur_tdr_set_max_sqhratio(par,0.25);
6079 gen = unur_init(par);
6080 if (gen) unur_tdr_chg_verify(gen,1);
6081 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[17],'~')==UNUR_SUCCESS)?0:1000;
6082 unur_free(gen);
6083
6084 unur_distr_free(distr_localcopy);
6085 } while (0);
6086 }
6087
6088 if(TRUE) {
6089 unur_reset_errno();
6090 do {
6091 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[17]);
6092 par = unur_tdr_new(distr_localcopy);
6093 unur_tdr_set_pedantic(par,0);
6094 unur_tdr_set_variant_ia(par);
6095 unur_tdr_set_c(par,0.);
6096 gen = unur_init(par);
6097 if (gen) unur_tdr_chg_verify(gen,1);
6098 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[17],'~')==UNUR_SUCCESS)?0:1000;
6099 unur_free(gen);
6100
6101 unur_distr_free(distr_localcopy);
6102 } while (0);
6103 }
6104
6105 if(TRUE) {
6106 unur_reset_errno();
6107 do {
6108 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[17]);
6109 par = unur_tdr_new(distr_localcopy);
6110 unur_tdr_set_pedantic(par,0);
6111 unur_tdr_set_variant_ia(par);
6112 unur_tdr_set_c(par,-0.5);
6113 unur_tdr_set_cpoints(par,30,NULL);
6114 unur_set_use_distr_privatecopy(par,FALSE);
6115 fpm[0] = 1.;
6116 fpm[1] = 4.;
6117 unur_distr_cont_set_pdfparams(distr_localcopy,fpm,2);
6118 gen = unur_init(par);
6119 if (gen) {
6120 unur_tdr_chg_reinit_percentiles(gen, 2, NULL );
6121 unur_reinit(gen);
6122 }
6123 if (gen) unur_tdr_chg_verify(gen,1);
6124 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[17],'~')==UNUR_SUCCESS)?0:1000;
6125 unur_free(gen);
6126
6127 unur_distr_free(distr_localcopy);
6128 } while (0);
6129 }
6130
6131 if(TRUE) {
6132 unur_reset_errno();
6133 do {
6134 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[17]);
6135 par = unur_tdr_new(distr_localcopy);
6136 unur_tdr_set_pedantic(par,0);
6137 unur_tdr_set_variant_ia(par);
6138 unur_tdr_set_c(par,0.);
6139 unur_tdr_set_cpoints(par,30,NULL);
6140 unur_set_use_distr_privatecopy(par,FALSE);
6141 fpm[0] = 1.;
6142 fpm[1] = 4.;
6143 unur_distr_cont_set_pdfparams(distr_localcopy,fpm,2);
6144 gen = unur_init(par);
6145 if (gen) {
6146 unur_tdr_chg_reinit_percentiles(gen, 2, NULL );
6147 unur_reinit(gen);
6148 }
6149 if (gen) unur_tdr_chg_verify(gen,1);
6150 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[17],'~')==UNUR_SUCCESS)?0:1000;
6151 unur_free(gen);
6152
6153 unur_distr_free(distr_localcopy);
6154 } while (0);
6155 }
6156
6157 /* distribution [18] */
6158
6159 if(fullcheck) {
6160 unur_reset_errno();
6161 do {
6162 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[18]);
6163 par = unur_tdr_new(distr_localcopy);
6164 unur_tdr_set_pedantic(par,0);
6165 unur_tdr_set_variant_ia(par);
6166 unur_tdr_set_c(par,-0.5);
6167 gen = unur_init(par);
6168 if (gen) unur_tdr_chg_verify(gen,1);
6169 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[18],'~')==UNUR_SUCCESS)?0:1000;
6170 unur_free(gen);
6171
6172 unur_distr_free(distr_localcopy);
6173 } while (0);
6174 }
6175
6176 if(fullcheck) {
6177 unur_reset_errno();
6178 do {
6179 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[18]);
6180 par = unur_tdr_new(distr_localcopy);
6181 unur_tdr_set_pedantic(par,0);
6182 unur_tdr_set_variant_ia(par);
6183 unur_tdr_set_c(par,-0.5);
6184 unur_tdr_set_usedars(par,FALSE);
6185 unur_tdr_set_cpoints(par,10,NULL);
6186 gen = unur_init(par);
6187 if (gen) unur_tdr_chg_verify(gen,1);
6188 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[18],'~')==UNUR_SUCCESS)?0:1000;
6189 unur_free(gen);
6190
6191 unur_distr_free(distr_localcopy);
6192 } while (0);
6193 }
6194
6195 if(fullcheck) {
6196 unur_reset_errno();
6197 do {
6198 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[18]);
6199 par = unur_tdr_new(distr_localcopy);
6200 unur_tdr_set_pedantic(par,0);
6201 unur_tdr_set_variant_ia(par);
6202 unur_tdr_set_c(par,-0.5);
6203 unur_tdr_set_usedars(par,FALSE);
6204 unur_tdr_set_cpoints(par,10,NULL);
6205 unur_tdr_set_max_sqhratio(par,0.25);
6206 gen = unur_init(par);
6207 if (gen) unur_tdr_chg_verify(gen,1);
6208 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[18],'~')==UNUR_SUCCESS)?0:1000;
6209 unur_free(gen);
6210
6211 unur_distr_free(distr_localcopy);
6212 } while (0);
6213 }
6214
6215 if(fullcheck) {
6216 unur_reset_errno();
6217 do {
6218 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[18]);
6219 par = unur_tdr_new(distr_localcopy);
6220 unur_tdr_set_pedantic(par,0);
6221 unur_tdr_set_variant_ia(par);
6222 unur_tdr_set_c(par,0.);
6223 gen = unur_init(par);
6224 if (gen) unur_tdr_chg_verify(gen,1);
6225 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[18],'~')==UNUR_SUCCESS)?0:1000;
6226 unur_free(gen);
6227
6228 unur_distr_free(distr_localcopy);
6229 } while (0);
6230 }
6231
6232 if(fullcheck) {
6233 printf("."); fflush(stdout);
6234 }
6235
6236 if(fullcheck) {
6237 printf("."); fflush(stdout);
6238 }
6239
6240 /* distribution [19] */
6241
6242 if(TRUE) {
6243 unur_reset_errno();
6244 do {
6245 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[19]);
6246 par = unur_tdr_new(distr_localcopy);
6247 unur_tdr_set_pedantic(par,0);
6248 unur_tdr_set_variant_ia(par);
6249 unur_tdr_set_c(par,-0.5);
6250 gen = unur_init(par);
6251 if (gen) unur_tdr_chg_verify(gen,1);
6252 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[19],'~')==UNUR_SUCCESS)?0:1000;
6253 unur_free(gen);
6254
6255 unur_distr_free(distr_localcopy);
6256 } while (0);
6257 }
6258
6259 if(TRUE) {
6260 unur_reset_errno();
6261 do {
6262 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[19]);
6263 par = unur_tdr_new(distr_localcopy);
6264 unur_tdr_set_pedantic(par,0);
6265 unur_tdr_set_variant_ia(par);
6266 unur_tdr_set_c(par,-0.5);
6267 unur_tdr_set_usedars(par,FALSE);
6268 unur_tdr_set_cpoints(par,10,NULL);
6269 gen = unur_init(par);
6270 if (gen) unur_tdr_chg_verify(gen,1);
6271 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[19],'~')==UNUR_SUCCESS)?0:1000;
6272 unur_free(gen);
6273
6274 unur_distr_free(distr_localcopy);
6275 } while (0);
6276 }
6277
6278 if(TRUE) {
6279 unur_reset_errno();
6280 do {
6281 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[19]);
6282 par = unur_tdr_new(distr_localcopy);
6283 unur_tdr_set_pedantic(par,0);
6284 unur_tdr_set_variant_ia(par);
6285 unur_tdr_set_c(par,-0.5);
6286 unur_tdr_set_usedars(par,FALSE);
6287 unur_tdr_set_cpoints(par,10,NULL);
6288 unur_tdr_set_max_sqhratio(par,0.25);
6289 gen = unur_init(par);
6290 if (gen) unur_tdr_chg_verify(gen,1);
6291 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[19],'~')==UNUR_SUCCESS)?0:1000;
6292 unur_free(gen);
6293
6294 unur_distr_free(distr_localcopy);
6295 } while (0);
6296 }
6297
6298 if(TRUE) {
6299 unur_reset_errno();
6300 do {
6301 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[19]);
6302 par = unur_tdr_new(distr_localcopy);
6303 unur_tdr_set_pedantic(par,0);
6304 unur_tdr_set_variant_ia(par);
6305 unur_tdr_set_c(par,0.);
6306 gen = unur_init(par);
6307 if (gen) unur_tdr_chg_verify(gen,1);
6308 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[19],'~')==UNUR_SUCCESS)?0:1000;
6309 unur_free(gen);
6310
6311 unur_distr_free(distr_localcopy);
6312 } while (0);
6313 }
6314
6315 if(TRUE) {
6316 printf("."); fflush(stdout);
6317 }
6318
6319 if(TRUE) {
6320 printf("."); fflush(stdout);
6321 }
6322
6323 /* distribution [20] */
6324
6325 if(TRUE) {
6326 unur_reset_errno();
6327 do {
6328 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[20]);
6329 par = unur_tdr_new(distr_localcopy);
6330 unur_tdr_set_pedantic(par,0);
6331 unur_tdr_set_variant_ia(par);
6332 unur_tdr_set_c(par,-0.5);
6333 gen = unur_init(par);
6334 if (gen) unur_tdr_chg_verify(gen,1);
6335 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[20],'~')==UNUR_SUCCESS)?0:1000;
6336 unur_free(gen);
6337
6338 unur_distr_free(distr_localcopy);
6339 } while (0);
6340 }
6341
6342 if(TRUE) {
6343 unur_reset_errno();
6344 do {
6345 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[20]);
6346 par = unur_tdr_new(distr_localcopy);
6347 unur_tdr_set_pedantic(par,0);
6348 unur_tdr_set_variant_ia(par);
6349 unur_tdr_set_c(par,-0.5);
6350 unur_tdr_set_usedars(par,FALSE);
6351 unur_tdr_set_cpoints(par,10,NULL);
6352 gen = unur_init(par);
6353 if (gen) unur_tdr_chg_verify(gen,1);
6354 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[20],'~')==UNUR_SUCCESS)?0:1000;
6355 unur_free(gen);
6356
6357 unur_distr_free(distr_localcopy);
6358 } while (0);
6359 }
6360
6361 if(TRUE) {
6362 unur_reset_errno();
6363 do {
6364 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[20]);
6365 par = unur_tdr_new(distr_localcopy);
6366 unur_tdr_set_pedantic(par,0);
6367 unur_tdr_set_variant_ia(par);
6368 unur_tdr_set_c(par,-0.5);
6369 unur_tdr_set_usedars(par,FALSE);
6370 unur_tdr_set_cpoints(par,10,NULL);
6371 unur_tdr_set_max_sqhratio(par,0.25);
6372 gen = unur_init(par);
6373 if (gen) unur_tdr_chg_verify(gen,1);
6374 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[20],'~')==UNUR_SUCCESS)?0:1000;
6375 unur_free(gen);
6376
6377 unur_distr_free(distr_localcopy);
6378 } while (0);
6379 }
6380
6381 if(TRUE) {
6382 unur_reset_errno();
6383 do {
6384 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[20]);
6385 par = unur_tdr_new(distr_localcopy);
6386 unur_tdr_set_pedantic(par,0);
6387 unur_tdr_set_variant_ia(par);
6388 unur_tdr_set_c(par,0.);
6389 gen = unur_init(par);
6390 if (gen) unur_tdr_chg_verify(gen,1);
6391 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[20],'~')==UNUR_SUCCESS)?0:1000;
6392 unur_free(gen);
6393
6394 unur_distr_free(distr_localcopy);
6395 } while (0);
6396 }
6397
6398 if(TRUE) {
6399 unur_reset_errno();
6400 do {
6401 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[20]);
6402 par = unur_tdr_new(distr_localcopy);
6403 unur_tdr_set_pedantic(par,0);
6404 unur_tdr_set_variant_ia(par);
6405 unur_tdr_set_c(par,-0.5);
6406 unur_tdr_set_cpoints(par,30,NULL);
6407 unur_set_use_distr_privatecopy(par,FALSE);
6408 fpm[0] = 1.;
6409 fpm[1] = 4.;
6410 unur_distr_cont_set_pdfparams(distr_localcopy,fpm,2);
6411 gen = unur_init(par);
6412 if (gen) {
6413 unur_tdr_chg_reinit_percentiles(gen, 2, NULL );
6414 unur_reinit(gen);
6415 }
6416 if (gen) unur_tdr_chg_verify(gen,1);
6417 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[20],'~')==UNUR_SUCCESS)?0:1000;
6418 unur_free(gen);
6419
6420 unur_distr_free(distr_localcopy);
6421 } while (0);
6422 }
6423
6424 if(TRUE) {
6425 unur_reset_errno();
6426 do {
6427 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[20]);
6428 par = unur_tdr_new(distr_localcopy);
6429 unur_tdr_set_pedantic(par,0);
6430 unur_tdr_set_variant_ia(par);
6431 unur_tdr_set_c(par,0.);
6432 unur_tdr_set_cpoints(par,30,NULL);
6433 unur_set_use_distr_privatecopy(par,FALSE);
6434 fpm[0] = 1.;
6435 fpm[1] = 4.;
6436 unur_distr_cont_set_pdfparams(distr_localcopy,fpm,2);
6437 gen = unur_init(par);
6438 if (gen) {
6439 unur_tdr_chg_reinit_percentiles(gen, 2, NULL );
6440 unur_reinit(gen);
6441 }
6442 if (gen) unur_tdr_chg_verify(gen,1);
6443 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[20],'~')==UNUR_SUCCESS)?0:1000;
6444 unur_free(gen);
6445
6446 unur_distr_free(distr_localcopy);
6447 } while (0);
6448 }
6449
6450 /* distribution [21] */
6451
6452 if(TRUE) {
6453 unur_reset_errno();
6454 do {
6455 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[21]);
6456 par = unur_tdr_new(distr_localcopy);
6457 unur_tdr_set_pedantic(par,0);
6458 unur_tdr_set_variant_ia(par);
6459 unur_tdr_set_c(par,-0.5);
6460 gen = unur_init(par);
6461 if (gen) unur_tdr_chg_verify(gen,1);
6462 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[21],'~')==UNUR_SUCCESS)?0:1000;
6463 unur_free(gen);
6464
6465 unur_distr_free(distr_localcopy);
6466 } while (0);
6467 }
6468
6469 if(TRUE) {
6470 unur_reset_errno();
6471 do {
6472 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[21]);
6473 par = unur_tdr_new(distr_localcopy);
6474 unur_tdr_set_pedantic(par,0);
6475 unur_tdr_set_variant_ia(par);
6476 unur_tdr_set_c(par,-0.5);
6477 unur_tdr_set_usedars(par,FALSE);
6478 unur_tdr_set_cpoints(par,10,NULL);
6479 gen = unur_init(par);
6480 if (gen) unur_tdr_chg_verify(gen,1);
6481 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[21],'~')==UNUR_SUCCESS)?0:1000;
6482 unur_free(gen);
6483
6484 unur_distr_free(distr_localcopy);
6485 } while (0);
6486 }
6487
6488 if(TRUE) {
6489 unur_reset_errno();
6490 do {
6491 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[21]);
6492 par = unur_tdr_new(distr_localcopy);
6493 unur_tdr_set_pedantic(par,0);
6494 unur_tdr_set_variant_ia(par);
6495 unur_tdr_set_c(par,-0.5);
6496 unur_tdr_set_usedars(par,FALSE);
6497 unur_tdr_set_cpoints(par,10,NULL);
6498 unur_tdr_set_max_sqhratio(par,0.25);
6499 gen = unur_init(par);
6500 if (gen) unur_tdr_chg_verify(gen,1);
6501 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[21],'~')==UNUR_SUCCESS)?0:1000;
6502 unur_free(gen);
6503
6504 unur_distr_free(distr_localcopy);
6505 } while (0);
6506 }
6507
6508 if(TRUE) {
6509 unur_reset_errno();
6510 do {
6511 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[21]);
6512 par = unur_tdr_new(distr_localcopy);
6513 unur_tdr_set_pedantic(par,0);
6514 unur_tdr_set_variant_ia(par);
6515 unur_tdr_set_c(par,0.);
6516 gen = unur_init(par);
6517 if (gen) unur_tdr_chg_verify(gen,1);
6518 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[21],'~')==UNUR_SUCCESS)?0:1000;
6519 unur_free(gen);
6520
6521 unur_distr_free(distr_localcopy);
6522 } while (0);
6523 }
6524
6525 if(TRUE) {
6526 printf("."); fflush(stdout);
6527 }
6528
6529 if(TRUE) {
6530 printf("."); fflush(stdout);
6531 }
6532
6533 /* distribution [22] */
6534
6535 if(TRUE) {
6536 unur_reset_errno();
6537 do {
6538 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[22]);
6539 par = unur_tdr_new(distr_localcopy);
6540 unur_tdr_set_pedantic(par,0);
6541 unur_tdr_set_variant_ia(par);
6542 unur_tdr_set_c(par,-0.5);
6543 gen = unur_init(par);
6544 if (gen) unur_tdr_chg_verify(gen,1);
6545 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[22],'~')==UNUR_SUCCESS)?0:1000;
6546 unur_free(gen);
6547
6548 unur_distr_free(distr_localcopy);
6549 } while (0);
6550 }
6551
6552 if(TRUE) {
6553 unur_reset_errno();
6554 do {
6555 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[22]);
6556 par = unur_tdr_new(distr_localcopy);
6557 unur_tdr_set_pedantic(par,0);
6558 unur_tdr_set_variant_ia(par);
6559 unur_tdr_set_c(par,-0.5);
6560 unur_tdr_set_usedars(par,FALSE);
6561 unur_tdr_set_cpoints(par,10,NULL);
6562 gen = unur_init(par);
6563 if (gen) unur_tdr_chg_verify(gen,1);
6564 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[22],'~')==UNUR_SUCCESS)?0:1000;
6565 unur_free(gen);
6566
6567 unur_distr_free(distr_localcopy);
6568 } while (0);
6569 }
6570
6571 if(TRUE) {
6572 unur_reset_errno();
6573 do {
6574 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[22]);
6575 par = unur_tdr_new(distr_localcopy);
6576 unur_tdr_set_pedantic(par,0);
6577 unur_tdr_set_variant_ia(par);
6578 unur_tdr_set_c(par,-0.5);
6579 unur_tdr_set_usedars(par,FALSE);
6580 unur_tdr_set_cpoints(par,10,NULL);
6581 unur_tdr_set_max_sqhratio(par,0.25);
6582 gen = unur_init(par);
6583 if (gen) unur_tdr_chg_verify(gen,1);
6584 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[22],'~')==UNUR_SUCCESS)?0:1000;
6585 unur_free(gen);
6586
6587 unur_distr_free(distr_localcopy);
6588 } while (0);
6589 }
6590
6591 if(TRUE) {
6592 unur_reset_errno();
6593 do {
6594 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[22]);
6595 par = unur_tdr_new(distr_localcopy);
6596 unur_tdr_set_pedantic(par,0);
6597 unur_tdr_set_variant_ia(par);
6598 unur_tdr_set_c(par,0.);
6599 gen = unur_init(par);
6600 if (gen) unur_tdr_chg_verify(gen,1);
6601 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[22],'~')==UNUR_SUCCESS)?0:1000;
6602 unur_free(gen);
6603
6604 unur_distr_free(distr_localcopy);
6605 } while (0);
6606 }
6607
6608 if(TRUE) {
6609 printf("."); fflush(stdout);
6610 }
6611
6612 if(TRUE) {
6613 printf("."); fflush(stdout);
6614 }
6615
6616 /* distribution [23] */
6617
6618 if(TRUE) {
6619 unur_reset_errno();
6620 do {
6621 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[23]);
6622 par = unur_tdr_new(distr_localcopy);
6623 unur_tdr_set_pedantic(par,0);
6624 unur_tdr_set_variant_ia(par);
6625 unur_tdr_set_c(par,-0.5);
6626 gen = unur_init(par);
6627 if (gen) unur_tdr_chg_verify(gen,1);
6628 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[23],'~')==UNUR_SUCCESS)?0:1000;
6629 unur_free(gen);
6630
6631 unur_distr_free(distr_localcopy);
6632 } while (0);
6633 }
6634
6635 if(TRUE) {
6636 unur_reset_errno();
6637 do {
6638 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[23]);
6639 par = unur_tdr_new(distr_localcopy);
6640 unur_tdr_set_pedantic(par,0);
6641 unur_tdr_set_variant_ia(par);
6642 unur_tdr_set_c(par,-0.5);
6643 unur_tdr_set_usedars(par,FALSE);
6644 unur_tdr_set_cpoints(par,10,NULL);
6645 gen = unur_init(par);
6646 if (gen) unur_tdr_chg_verify(gen,1);
6647 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[23],'~')==UNUR_SUCCESS)?0:1000;
6648 unur_free(gen);
6649
6650 unur_distr_free(distr_localcopy);
6651 } while (0);
6652 }
6653
6654 if(TRUE) {
6655 unur_reset_errno();
6656 do {
6657 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[23]);
6658 par = unur_tdr_new(distr_localcopy);
6659 unur_tdr_set_pedantic(par,0);
6660 unur_tdr_set_variant_ia(par);
6661 unur_tdr_set_c(par,-0.5);
6662 unur_tdr_set_usedars(par,FALSE);
6663 unur_tdr_set_cpoints(par,10,NULL);
6664 unur_tdr_set_max_sqhratio(par,0.25);
6665 gen = unur_init(par);
6666 if (gen) unur_tdr_chg_verify(gen,1);
6667 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[23],'~')==UNUR_SUCCESS)?0:1000;
6668 unur_free(gen);
6669
6670 unur_distr_free(distr_localcopy);
6671 } while (0);
6672 }
6673
6674 if(TRUE) {
6675 unur_reset_errno();
6676 do {
6677 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[23]);
6678 par = unur_tdr_new(distr_localcopy);
6679 unur_tdr_set_pedantic(par,0);
6680 unur_tdr_set_variant_ia(par);
6681 unur_tdr_set_c(par,0.);
6682 gen = unur_init(par);
6683 if (gen) unur_tdr_chg_verify(gen,1);
6684 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[23],'~')==UNUR_SUCCESS)?0:1000;
6685 unur_free(gen);
6686
6687 unur_distr_free(distr_localcopy);
6688 } while (0);
6689 }
6690
6691 if(TRUE) {
6692 printf("."); fflush(stdout);
6693 }
6694
6695 if(TRUE) {
6696 printf("."); fflush(stdout);
6697 }
6698
6699 /* distribution [28] */
6700
6701 if(TRUE) {
6702 unur_reset_errno();
6703 do {
6704 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[28]);
6705 par = unur_tdr_new(distr_localcopy);
6706 unur_tdr_set_pedantic(par,0);
6707 unur_tdr_set_variant_ia(par);
6708 unur_tdr_set_c(par,-0.5);
6709 gen = unur_init(par);
6710 if (gen) unur_tdr_chg_verify(gen,1);
6711 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[28],'~')==UNUR_SUCCESS)?0:1000;
6712 unur_free(gen);
6713
6714 unur_distr_free(distr_localcopy);
6715 } while (0);
6716 }
6717
6718 if(TRUE) {
6719 unur_reset_errno();
6720 do {
6721 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[28]);
6722 par = unur_tdr_new(distr_localcopy);
6723 unur_tdr_set_pedantic(par,0);
6724 unur_tdr_set_variant_ia(par);
6725 unur_tdr_set_c(par,-0.5);
6726 unur_tdr_set_usedars(par,FALSE);
6727 unur_tdr_set_cpoints(par,10,NULL);
6728 gen = unur_init(par);
6729 if (gen) unur_tdr_chg_verify(gen,1);
6730 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[28],'~')==UNUR_SUCCESS)?0:1000;
6731 unur_free(gen);
6732
6733 unur_distr_free(distr_localcopy);
6734 } while (0);
6735 }
6736
6737 if(TRUE) {
6738 unur_reset_errno();
6739 do {
6740 UNUR_DISTR *distr_localcopy = unur_distr_clone(distr[28]);
6741 par = unur_tdr_new(distr_localcopy);
6742 unur_tdr_set_pedantic(par,0);
6743 unur_tdr_set_variant_ia(par);
6744 unur_tdr_set_c(par,-0.5);
6745 unur_tdr_set_usedars(par,FALSE);
6746 unur_tdr_set_cpoints(par,10,NULL);
6747 unur_tdr_set_max_sqhratio(par,0.25);
6748 gen = unur_init(par);
6749 if (gen) unur_tdr_chg_verify(gen,1);
6750 n_tests_failed += (run_validate_verifyhat(TESTLOG,0,gen,distr[28],'~')==UNUR_SUCCESS)?0:1000;
6751 unur_free(gen);
6752
6753 unur_distr_free(distr_localcopy);
6754 } while (0);
6755 }
6756
6757 if(TRUE) {
6758 printf("."); fflush(stdout);
6759 }
6760
6761 if(TRUE) {
6762 printf("."); fflush(stdout);
6763 }
6764
6765 if(TRUE) {
6766 printf("."); fflush(stdout);
6767 }
6768
6769 /* distribution [29] */
6770
6771 if(TRUE) {
6772 printf("."); fflush(stdout);
6773 }
6774
6775 if(TRUE) {
6776 printf("."); fflush(stdout);
6777 }
6778
6779 if(TRUE) {
6780 printf("."); fflush(stdout);
6781 }
6782
6783 if(TRUE) {
6784 printf("."); fflush(stdout);
6785 }
6786
6787 if(TRUE) {
6788 printf("."); fflush(stdout);
6789 }
6790
6791 if(TRUE) {
6792 printf("."); fflush(stdout);
6793 }
6794
6795 /* timing */
6796 stopwatch_print(TESTLOG,"\n<*>time = %.0f ms\n", stopwatch_lap(&watch));
6797
6798
6799 /* free distributions */
6800 unur_distr_free(distr[0]);
6801 unur_distr_free(distr[1]);
6802 unur_distr_free(distr[2]);
6803 unur_distr_free(distr[3]);
6804 unur_distr_free(distr[4]);
6805 unur_distr_free(distr[5]);
6806 unur_distr_free(distr[6]);
6807 unur_distr_free(distr[7]);
6808 unur_distr_free(distr[8]);
6809 unur_distr_free(distr[9]);
6810 unur_distr_free(distr[10]);
6811 unur_distr_free(distr[11]);
6812 unur_distr_free(distr[12]);
6813 unur_distr_free(distr[13]);
6814 unur_distr_free(distr[14]);
6815 unur_distr_free(distr[15]);
6816 unur_distr_free(distr[16]);
6817 unur_distr_free(distr[17]);
6818 unur_distr_free(distr[18]);
6819 unur_distr_free(distr[19]);
6820 unur_distr_free(distr[20]);
6821 unur_distr_free(distr[21]);
6822 unur_distr_free(distr[22]);
6823 unur_distr_free(distr[23]);
6824 unur_distr_free(distr[24]);
6825 unur_distr_free(distr[25]);
6826 unur_distr_free(distr[26]);
6827 unur_distr_free(distr[27]);
6828 unur_distr_free(distr[28]);
6829 unur_distr_free(distr[29]);
6830 unur_distr_free(distr[30]);
6831 unur_distr_free(distr[31]);
6832
6833 /* test finished */
6834 test_ok &= (n_tests_failed>CHI2_FAILURES_TOLERATED) ? 0 : 1;
6835 /* we accept CHI2_FAILURES_TOLERATED failures */
6836 (n_tests_failed>CHI2_FAILURES_TOLERATED) ? printf(" ==> failed] ") : printf(" ==> ok] ");
6837
6838 /* prevent compiler from making useless annoying warnings */
6839 distr[0] = NULL;
6840 par = NULL;
6841 gen = NULL;
6842 darray = NULL;
6843 fpm[0] = 0.;
6844
6845 } /* end of test_validate */
6846
6847
6848 /*---------------------------------------------------------------------------*/
6849 /* run generator in verifying mode */
6850
run_verify_generator(FILE * LOG,int line,UNUR_PAR * par)6851 void run_verify_generator( FILE *LOG, int line, UNUR_PAR *par )
6852 {
6853 UNUR_GEN *gen;
6854 int i;
6855
6856 /* switch to verifying mode */
6857 unur_tdr_set_verify(par,1);
6858
6859 /* initialize generator */
6860 gen = unur_init( par ); abort_if_NULL(LOG, line, gen);
6861
6862 /* run generator */
6863 for (i=0; i<VIOLATE_SAMPLE_SIZE; i++)
6864 unur_sample_cont(gen);
6865
6866 /* destroy generator */
6867 unur_free(gen);
6868
6869 } /* end of run_verify_generator() */
6870
6871
6872 /*---------------------------------------------------------------------------*/
6873
main(void)6874 int main(void)
6875 {
6876 unsigned long seed;
6877 char *str_seed, *str_tail;
6878
6879 /* start stop watch */
6880 stopwatch_init();
6881 stopwatch_start(&watch);
6882
6883 /* open log file for unuran and set output stream for unuran messages */
6884 UNURANLOG = fopen( "t_tdr_ia_unuran.log","w" );
6885 abort_if_NULL( stderr,-1, UNURANLOG );
6886 unur_set_stream( UNURANLOG );
6887
6888 /* open log file for testing */
6889 TESTLOG = fopen( "t_tdr_ia_test.log","w" );
6890 abort_if_NULL( stderr,-1, TESTLOG );
6891
6892 /* seed for uniform generators */
6893
6894 /* seed set by environment */
6895 str_seed = getenv("SEED");
6896
6897 if (str_seed != NULL) {
6898 seed = strtol(str_seed, &str_tail, 10);
6899 if (seed == 0u)
6900 seed = 383877;
6901 }
6902 else {
6903 #ifdef SEED
6904 seed = SEED;
6905 #else
6906 seed = 383877;
6907 #endif
6908 }
6909
6910 /* seed build-in uniform generators */
6911 unur_urng_MRG31k3p_seed(NULL,seed);
6912 unur_urng_fish_seed(NULL,seed);
6913 unur_urng_mstd_seed(NULL,seed);
6914
6915 /* seed uniform random number generator */
6916 #ifdef UNUR_URNG_UNURAN
6917 # ifdef UNUR_URNG_DEFAULT_RNGSTREAM
6918 {
6919 unsigned long sa[6];
6920 int i;
6921 for (i=0; i<6; i++) sa[i] = seed;
6922 RngStream_SetPackageSeed(sa);
6923 }
6924 # else
6925 if (unur_urng_seed(NULL,seed) != UNUR_SUCCESS) {
6926 fprintf(stderr,"WARNING: Seed could not be set at random\n");
6927 seed = ~0u;
6928 }
6929 # endif /* UNUR_URNG_DEFAULT_RNGSTREAM */
6930 #endif /* UNUR_URNG_UNURAN */
6931
6932 /* set default debugging flag */
6933 unur_set_default_debug(UNUR_DEBUG_ALL);
6934
6935 /* detect required check mode */
6936 fullcheck = (getenv("UNURANFULLCHECK")==NULL) ? FALSE : TRUE;
6937
6938 /* write header into log file */
6939 print_test_log_header( TESTLOG, seed, fullcheck );
6940
6941 /* set timer for sending SIGALRM signal */
6942 set_alarm(TESTLOG);
6943
6944 /* start test */
6945 printf("tdr: ");
6946
6947 /* run tests */
6948 test_new();
6949 test_validate();
6950
6951
6952 /* test finished */
6953 printf("\n"); fflush(stdout);
6954
6955 /* close log files */
6956 fprintf(TESTLOG,"\n====================================================\n\n");
6957 if (test_ok)
6958 fprintf(TESTLOG,"All tests PASSED.\n");
6959 else
6960 fprintf(TESTLOG,"Test(s) FAILED.\n");
6961
6962 /* timing */
6963 stopwatch_print(TESTLOG,"\n<*>total time = %.0f ms\n\n", stopwatch_stop(&watch));
6964
6965 fclose(UNURANLOG);
6966 fclose(TESTLOG);
6967
6968 /* free memory */
6969 compare_free_memory();
6970 unur_urng_free(unur_get_default_urng());
6971 unur_urng_free(unur_get_default_urng_aux());
6972
6973 /* exit */
6974 exit( (test_ok) ? EXIT_SUCCESS : EXIT_FAILURE );
6975
6976 } /* end of main */
6977
6978