| 1 |
;; NOTE: for zipf tests data can be exported, this can be enabled by uncommenting appropriate lines. |
| 2 |
|
| 3 |
(import |
| 4 |
(scheme base) |
| 5 |
(scheme inexact) |
| 6 |
(scheme complex) |
| 7 |
(scheme cxr) |
| 8 |
(scheme file) |
| 9 |
(scheme write) |
| 10 |
(srfi 1) |
| 11 |
(srfi 27) |
| 12 |
(srfi 133) |
| 13 |
(srfi 194)) |
| 14 |
|
| 15 |
(cond-expand |
| 16 |
((library (srfi 158)) (import (srfi 158))) |
| 17 |
((library (srfi 121)) (import (srfi 121)))) |
| 18 |
|
| 19 |
(cond-expand |
| 20 |
(chibi (begin |
| 21 |
(import (except (chibi test) test-equal)) |
| 22 |
(define-syntax test-equal |
| 23 |
(syntax-rules () |
| 24 |
((_ args ...) (test args ...)))) |
| 25 |
(define-syntax test-approximate |
| 26 |
(syntax-rules () |
| 27 |
((_ target value max-delta) |
| 28 |
(test-assert (and (<= value (+ target max-delta)) |
| 29 |
(>= value (- target max-delta))))))))) |
| 30 |
(else (import (srfi 64)))) |
| 31 |
|
| 32 |
;; syntax just we can plop it at top and still allow internal `define`s |
| 33 |
(define-syntax reset-source! |
| 34 |
(syntax-rules () |
| 35 |
((_) |
| 36 |
(define _ (random-source-pseudo-randomize! (current-random-source) 0 0))))) |
| 37 |
|
| 38 |
(define (reset-source!*) |
| 39 |
(random-source-pseudo-randomize! (current-random-source) 0 0)) |
| 40 |
|
| 41 |
(define (assert-number-generator/all-in-range gen from to) |
| 42 |
(test-assert |
| 43 |
(generator-every |
| 44 |
(lambda (num) |
| 45 |
(and (>= num from) |
| 46 |
(< num to))) |
| 47 |
(gtake gen 1000)))) |
| 48 |
|
| 49 |
(define (assert-number-generator gen from to) |
| 50 |
(define range (- to from)) |
| 51 |
(define lower-quarter (+ from (* 0.25 range))) |
| 52 |
(define upper-quarter (- to (* 0.25 range))) |
| 53 |
(assert-number-generator/all-in-range gen from to) |
| 54 |
|
| 55 |
(test-assert |
| 56 |
(generator-any |
| 57 |
(lambda (num) |
| 58 |
(and (>= num from) |
| 59 |
(< num lower-quarter))) |
| 60 |
(gtake gen 1000))) |
| 61 |
|
| 62 |
(test-assert |
| 63 |
(generator-any |
| 64 |
(lambda (num) |
| 65 |
(and (>= num lower-quarter) |
| 66 |
(< num upper-quarter))) |
| 67 |
(gtake gen 1000))) |
| 68 |
|
| 69 |
(test-assert |
| 70 |
(generator-any |
| 71 |
(lambda (num) |
| 72 |
(and (>= num upper-quarter) |
| 73 |
(< num to))) |
| 74 |
(gtake gen 1000)))) |
| 75 |
|
| 76 |
(define (assert-int-generator gen byte-size signed?) |
| 77 |
(define from (if signed? |
| 78 |
(- (expt 2 (- byte-size 1))) |
| 79 |
0)) |
| 80 |
(define to (if signed? |
| 81 |
(expt 2 (- byte-size 1)) |
| 82 |
(expt 2 byte-size))) |
| 83 |
(assert-number-generator gen from to)) |
| 84 |
|
| 85 |
(test-begin "srfi-194") |
| 86 |
|
| 87 |
(test-group "Test clamp real number" |
| 88 |
(reset-source!) |
| 89 |
(test-equal 10.0 (clamp-real-number 5.0 10.0 11)) |
| 90 |
(test-equal 5.0 (clamp-real-number 5.0 10.0 2.0)) |
| 91 |
(test-equal 7.5 (clamp-real-number 5.0 10.0 7.5))) |
| 92 |
|
| 93 |
(test-group "Test with-random-source basic syntax" |
| 94 |
(reset-source!) |
| 95 |
(with-random-source default-random-source |
| 96 |
(lambda () (make-random-integer-generator 0 10)))) |
| 97 |
|
| 98 |
;; testing random source, which is implementation specific |
| 99 |
(cond-expand |
| 100 |
(gauche |
| 101 |
(import |
| 102 |
(gauche base) |
| 103 |
(math mt-random)) |
| 104 |
(test-group "Test with-random-source" |
| 105 |
(reset-source!) |
| 106 |
;;create and consume generators that are made with different source |
| 107 |
;;with various order, and check that order doesn't change the outcome |
| 108 |
(define (test-multiple-sources gen1-maker gen1-expect |
| 109 |
gen2-maker gen2-expect) |
| 110 |
|
| 111 |
;;create gen1, consume gen1, create gen2, consume gen2 |
| 112 |
(let ((gen1 (gen1-maker))) |
| 113 |
(test-equal (generator->list gen1) gen1-expect) |
| 114 |
(let ((gen2 (gen2-maker))) |
| 115 |
(test-equal (generator->list gen2) gen2-expect))) |
| 116 |
|
| 117 |
;;create gen1, create gen2, consume gen1, consume gen2 |
| 118 |
(let ((gen1 (gen1-maker)) |
| 119 |
(gen2 (gen2-maker))) |
| 120 |
(test-equal (generator->list gen1) gen1-expect) |
| 121 |
(test-equal (generator->list gen2) gen2-expect))) |
| 122 |
|
| 123 |
(define multiple-sources-testcase |
| 124 |
(list (lambda () |
| 125 |
(gtake (with-random-source |
| 126 |
(make <mersenne-twister> :seed 0) |
| 127 |
(lambda () (make-random-integer-generator 0 10))) |
| 128 |
5)) |
| 129 |
'(5 5 7 8 6) |
| 130 |
(lambda () |
| 131 |
(gtake (with-random-source |
| 132 |
(make <mersenne-twister> :seed 1) |
| 133 |
(lambda () (make-random-integer-generator 0 10))) |
| 134 |
5)) |
| 135 |
'(4 9 7 9 0))) |
| 136 |
(apply test-multiple-sources multiple-sources-testcase)))) |
| 137 |
|
| 138 |
(test-group "Test make-random-source-generator" |
| 139 |
(reset-source!) |
| 140 |
(define (make-numbers src-gen) |
| 141 |
(define gen1 (with-random-source (src-gen) (lambda () (make-random-integer-generator 0 100)))) |
| 142 |
(define gen2 (with-random-source (src-gen) (lambda () (make-random-real-generator 0. 100.)))) |
| 143 |
(generator->list |
| 144 |
(gappend |
| 145 |
(gtake gen1 10) |
| 146 |
(gtake gen2 10)))) |
| 147 |
|
| 148 |
(test-equal |
| 149 |
(make-numbers (make-random-source-generator 0)) |
| 150 |
(make-numbers (make-random-source-generator 0))) |
| 151 |
(test-assert |
| 152 |
(not (equal? (make-numbers (make-random-source-generator 0)) |
| 153 |
(make-numbers (make-random-source-generator 1)))))) |
| 154 |
(test-group "Test random int" |
| 155 |
(reset-source!) |
| 156 |
(assert-number-generator |
| 157 |
(make-random-integer-generator 1 100) |
| 158 |
1 100) |
| 159 |
|
| 160 |
(for-each |
| 161 |
(lambda (testcase) |
| 162 |
(define make-gen (car testcase)) |
| 163 |
(define byte-size (cadr testcase)) |
| 164 |
(define signed? (caddr testcase)) |
| 165 |
(assert-int-generator (make-gen) byte-size signed?)) |
| 166 |
(list |
| 167 |
(list make-random-u8-generator 8 #f) |
| 168 |
(list make-random-s8-generator 8 #t) |
| 169 |
(list make-random-u16-generator 16 #f) |
| 170 |
(list make-random-s16-generator 16 #t) |
| 171 |
(list make-random-u32-generator 32 #f) |
| 172 |
(list make-random-s32-generator 32 #t) |
| 173 |
(list make-random-u64-generator 64 #f) |
| 174 |
(list make-random-s64-generator 64 #t))) |
| 175 |
|
| 176 |
;;test u1 separately, since it will fail quarter checks due to small range |
| 177 |
(assert-number-generator/all-in-range (make-random-u1-generator) 0 2) |
| 178 |
(test-assert |
| 179 |
(generator-any |
| 180 |
(lambda (v) (= v 0)) |
| 181 |
(gtake (make-random-u1-generator) 100))) |
| 182 |
(test-assert |
| 183 |
(generator-any |
| 184 |
(lambda (v) (= v 1)) |
| 185 |
(gtake (make-random-u1-generator) 100)))) |
| 186 |
|
| 187 |
(test-group "Test random real" |
| 188 |
(reset-source!) |
| 189 |
(assert-number-generator |
| 190 |
(make-random-real-generator 1.0 5.0) |
| 191 |
1.0 5.0) |
| 192 |
|
| 193 |
(test-assert |
| 194 |
(generator-any |
| 195 |
(lambda (v) |
| 196 |
(not (= v (floor v)))) |
| 197 |
(make-random-real-generator 1.0 5.0)))) |
| 198 |
|
| 199 |
(test-group "Test complex rectangular" |
| 200 |
(reset-source!) |
| 201 |
|
| 202 |
(assert-number-generator |
| 203 |
(gmap |
| 204 |
real-part |
| 205 |
(make-random-rectangular-generator -10.0 10.0 -100.0 100.0)) |
| 206 |
-10 10) |
| 207 |
|
| 208 |
(assert-number-generator |
| 209 |
(gmap |
| 210 |
imag-part |
| 211 |
(make-random-rectangular-generator -100.0 100.0 -10.0 10.0)) |
| 212 |
-10 10) |
| 213 |
|
| 214 |
(test-assert |
| 215 |
(generator-any |
| 216 |
(lambda (num) |
| 217 |
(and (not (= 0 (real-part num))) |
| 218 |
(not (= 0 (imag-part num))))) |
| 219 |
(make-random-rectangular-generator -10.0 10.0 -10.0 10.0)))) |
| 220 |
(test-group "Test complex polar" |
| 221 |
(reset-source!) |
| 222 |
(define PI (* 4 (atan 1.0))) |
| 223 |
|
| 224 |
(define (test-polar g origin mag-from mag-to angle-from angle-to test-converge-origin) |
| 225 |
(assert-number-generator |
| 226 |
(gmap |
| 227 |
(lambda (num) |
| 228 |
(angle (- num origin))) |
| 229 |
g) |
| 230 |
angle-from angle-to) |
| 231 |
|
| 232 |
(assert-number-generator |
| 233 |
(gmap |
| 234 |
(lambda (num) |
| 235 |
(magnitude (- num origin))) |
| 236 |
g) |
| 237 |
mag-from mag-to) |
| 238 |
|
| 239 |
;; split generated area through circle at 0.5*(mag-from + mag-to) |
| 240 |
;; and validate generated points in them proportional to their area |
| 241 |
(let* ((outter-count 0) |
| 242 |
(inner-count 0) |
| 243 |
(donut-area (lambda (r1 r2) (- (* r1 r1) (* r2 r2)))) |
| 244 |
(mag-mid (/ (+ mag-from mag-to) 2.)) |
| 245 |
(expected-fraction (/ (donut-area mag-to mag-mid) |
| 246 |
(donut-area mag-mid mag-from)))) |
| 247 |
(generator-for-each |
| 248 |
(lambda (point) |
| 249 |
(if (< (magnitude (- point origin)) mag-mid) |
| 250 |
(set! inner-count (+ 1 inner-count)) |
| 251 |
(set! outter-count (+ 1 outter-count)))) |
| 252 |
(gtake g 10000)) |
| 253 |
(test-approximate expected-fraction (/ outter-count inner-count) 0.2)) |
| 254 |
|
| 255 |
;; test points converge to center |
| 256 |
(when test-converge-origin |
| 257 |
(let ((sum 0+0i)) |
| 258 |
(generator-for-each |
| 259 |
(lambda (point) (set! sum (+ point sum))) |
| 260 |
(gtake g 1000)) |
| 261 |
(test-approximate (real-part origin) (real-part (/ sum 1000.)) 0.1) |
| 262 |
(test-approximate (imag-part origin) (imag-part (/ sum 1000.)) 0.1)))) |
| 263 |
|
| 264 |
|
| 265 |
(test-polar (make-random-polar-generator 0. 1.) |
| 266 |
0+0i 0. 1. (- PI) PI #t) |
| 267 |
|
| 268 |
(test-polar (make-random-polar-generator 2+5i 1. 2.) |
| 269 |
2+5i 1. 2. (- PI) PI #t) |
| 270 |
|
| 271 |
(test-polar (make-random-polar-generator 1. 2. -1. 1.) |
| 272 |
0+0i 1. 2. -1. 1. #f) |
| 273 |
|
| 274 |
(test-polar (make-random-polar-generator -1+3i 0. 2. (- PI) PI) |
| 275 |
-1+3i 0. 2. (- PI) PI #t)) |
| 276 |
|
| 277 |
(test-group "Test random bool" |
| 278 |
(reset-source!) |
| 279 |
(test-assert |
| 280 |
(generator-every |
| 281 |
(lambda (v) |
| 282 |
(or (eq? v #t) |
| 283 |
(eq? v #f))) |
| 284 |
(gtake (make-random-boolean-generator) 10000))) |
| 285 |
|
| 286 |
(test-assert |
| 287 |
(generator-any |
| 288 |
(lambda (v) |
| 289 |
(eq? #t v)) |
| 290 |
(make-random-boolean-generator))) |
| 291 |
|
| 292 |
(test-assert |
| 293 |
(generator-any |
| 294 |
(lambda (v) |
| 295 |
(eq? #f v)) |
| 296 |
(make-random-boolean-generator)))) |
| 297 |
|
| 298 |
(test-group "Test random char" |
| 299 |
(reset-source!) |
| 300 |
(test-assert |
| 301 |
(generator-every |
| 302 |
(lambda (v) |
| 303 |
(or (equal? v #\a) |
| 304 |
(equal? v #\b))) |
| 305 |
(gtake (make-random-char-generator "ab") |
| 306 |
10000))) |
| 307 |
|
| 308 |
(test-assert |
| 309 |
(generator-any |
| 310 |
(lambda (v) |
| 311 |
(equal? v #\a)) |
| 312 |
(make-random-char-generator "ab"))) |
| 313 |
|
| 314 |
(test-assert |
| 315 |
(generator-any |
| 316 |
(lambda (v) |
| 317 |
(equal? v #\b)) |
| 318 |
(make-random-char-generator "ab")))) |
| 319 |
|
| 320 |
(test-group "Test random string" |
| 321 |
(reset-source!) |
| 322 |
(test-assert |
| 323 |
(generator-every |
| 324 |
(lambda (str) |
| 325 |
(and (< (string-length str) 5) |
| 326 |
(every (lambda (c) |
| 327 |
(or (equal? c #\a) |
| 328 |
(equal? c #\b))) |
| 329 |
(string->list str)))) |
| 330 |
(gtake (make-random-string-generator 5 "ab") |
| 331 |
10000))) |
| 332 |
|
| 333 |
(test-assert |
| 334 |
(generator-any |
| 335 |
(lambda (str) |
| 336 |
(equal? "abb" str)) |
| 337 |
(make-random-string-generator 4 "ab")))) |
| 338 |
|
| 339 |
(test-group "Test Bernoulli" |
| 340 |
(reset-source!) |
| 341 |
(define g (make-bernoulli-generator 0.7)) |
| 342 |
(define expect 7000) |
| 343 |
(define actual (generator-count |
| 344 |
(lambda (i) (= i 1)) |
| 345 |
(gtake g 10000))) |
| 346 |
(define ratio (inexact (/ actual expect))) |
| 347 |
(test-assert (> ratio 0.9)) |
| 348 |
(test-assert (< ratio 1.1))) |
| 349 |
|
| 350 |
(test-group "Test categorical" |
| 351 |
(reset-source!) |
| 352 |
(define result-vec (vector 0 0 0)) |
| 353 |
(define expect-vec (vector 2000 5000 3000)) |
| 354 |
(define wvec (vector 20 50 30)) |
| 355 |
(define g (make-categorical-generator wvec)) |
| 356 |
(generator-for-each |
| 357 |
(lambda (i) |
| 358 |
(vector-set! result-vec i (+ 1 (vector-ref result-vec i)))) |
| 359 |
(gtake g 10000)) |
| 360 |
(vector-for-each |
| 361 |
(lambda (result expect) |
| 362 |
(define ratio (inexact (/ result expect))) |
| 363 |
(test-approximate 1.0 ratio 0.1)) |
| 364 |
result-vec |
| 365 |
expect-vec)) |
| 366 |
|
| 367 |
(test-group "Test poisson" |
| 368 |
(reset-source!) |
| 369 |
;;TODO import from somewhere? |
| 370 |
(define (fact k) |
| 371 |
(cond |
| 372 |
((<= k 1) 1) |
| 373 |
(else (* k (fact (- k 1)))))) |
| 374 |
(define (expected-fraction L k) |
| 375 |
(/ (* (exact (expt L k)) (exact (exp (- L)))) |
| 376 |
(fact k))) |
| 377 |
|
| 378 |
(define (test-poisson L poisson-gen test-points) |
| 379 |
(generator-every |
| 380 |
(lambda (k) |
| 381 |
(define expect (expected-fraction L k)) |
| 382 |
(define actual (/ (generator-count |
| 383 |
(lambda (i) (= i k)) |
| 384 |
(gtake poisson-gen 10000)) |
| 385 |
10000)) |
| 386 |
(define ratio (/ actual expect)) |
| 387 |
(test-assert (> ratio 8/10)) |
| 388 |
(test-assert (< ratio 12/10)) |
| 389 |
#t) |
| 390 |
(list->generator test-points))) |
| 391 |
|
| 392 |
(test-poisson 2 (make-poisson-generator 2) '(1 2 3)) |
| 393 |
(test-poisson 40 (make-poisson-generator 40) '(30 40 50)) |
| 394 |
(test-poisson 280 (make-poisson-generator 280) '(260 280 300))) |
| 395 |
|
| 396 |
(test-group "Test normal" |
| 397 |
(reset-source!) |
| 398 |
(define frac-at-1dev 0.34134) |
| 399 |
(define frac-at-2dev 0.47725) |
| 400 |
(define frac-at-3dev 0.49865) |
| 401 |
|
| 402 |
(define (test-normal-at-point gen count-from count-to expected-fraction) |
| 403 |
(define actual (/ (generator-count |
| 404 |
(lambda (n) |
| 405 |
(and (>= n count-from) |
| 406 |
(< n count-to))) |
| 407 |
(gtake gen 10000)) |
| 408 |
10000.0)) |
| 409 |
(test-assert (and (> actual (* 0.9 expected-fraction)) |
| 410 |
(< actual (* 1.1 expected-fraction))))) |
| 411 |
|
| 412 |
(define (test-normal gen mean deviation) |
| 413 |
(test-normal-at-point gen mean (+ mean deviation) frac-at-1dev) |
| 414 |
(test-normal-at-point gen mean (+ mean (* 2 deviation)) frac-at-2dev) |
| 415 |
(test-normal-at-point gen mean (+ mean (* 3 deviation)) frac-at-3dev)) |
| 416 |
|
| 417 |
(test-normal (make-normal-generator) 0.0 1.0) |
| 418 |
(test-normal (make-normal-generator 1.0) 1.0 1.0) |
| 419 |
(test-normal (make-normal-generator 1.0 2.0) 1.0 2.0)) |
| 420 |
|
| 421 |
(test-group "Test exponential" |
| 422 |
(reset-source!) |
| 423 |
(define (expected-fraction mean x) |
| 424 |
(- 1 (exp (* (- (/ 1.0 mean)) x)))) |
| 425 |
|
| 426 |
(define (test-exp-at-point gen count-to expected) |
| 427 |
(define actual (/ (generator-count |
| 428 |
(lambda (n) |
| 429 |
(< n count-to)) |
| 430 |
(gtake gen 10000)) |
| 431 |
10000.0)) |
| 432 |
(test-assert (> actual (* 0.9 expected))) |
| 433 |
(test-assert (< actual (* 1.1 expected)))) |
| 434 |
|
| 435 |
(define (test-exp gen mean) |
| 436 |
(test-exp-at-point gen 1 (expected-fraction mean 1)) |
| 437 |
(test-exp-at-point gen 2 (expected-fraction mean 2)) |
| 438 |
(test-exp-at-point gen 3 (expected-fraction mean 3))) |
| 439 |
|
| 440 |
(test-exp (make-exponential-generator 1) 1) |
| 441 |
(test-exp (make-exponential-generator 1.5) 1.5)) |
| 442 |
|
| 443 |
(test-group "Test geometric" |
| 444 |
(reset-source!) |
| 445 |
(define (expected-fraction p x) |
| 446 |
(* (expt (- 1 p) (- x 1)) p)) |
| 447 |
|
| 448 |
(define (test-geom-at-point gen p x) |
| 449 |
(define expected (expected-fraction p x)) |
| 450 |
(define actual (/ (generator-count |
| 451 |
(lambda (n) |
| 452 |
(= n x)) |
| 453 |
(gtake gen 100000)) |
| 454 |
100000)) |
| 455 |
(define ratio (/ actual expected)) |
| 456 |
(test-assert (> ratio 0.9)) |
| 457 |
(test-assert (< ratio 1.1))) |
| 458 |
|
| 459 |
(define (test-geom gen p) |
| 460 |
(test-geom-at-point gen p 1) |
| 461 |
(test-geom-at-point gen p 3) |
| 462 |
(test-geom-at-point gen p 5)) |
| 463 |
|
| 464 |
(test-geom (make-geometric-generator 0.5) 0.5)) |
| 465 |
|
| 466 |
(test-group "Test uniform sampling" |
| 467 |
(reset-source!) |
| 468 |
(test-equal |
| 469 |
'() |
| 470 |
(generator->list (gsampling))) |
| 471 |
(test-equal |
| 472 |
'() |
| 473 |
(generator->list (gsampling (generator) (generator)))) |
| 474 |
(test-equal |
| 475 |
'(1 1 1) |
| 476 |
(generator->list (gsampling (generator) (generator 1 1 1)))) |
| 477 |
(test-assert |
| 478 |
(generator-any |
| 479 |
(lambda (el) |
| 480 |
(= el 1)) |
| 481 |
(gsampling (circular-generator 1) (circular-generator 2)))) |
| 482 |
(test-assert |
| 483 |
(generator-any |
| 484 |
(lambda (el) |
| 485 |
(= el 2)) |
| 486 |
(gsampling (circular-generator 1) (circular-generator 2))))) |
| 487 |
|
| 488 |
; See zipf-test.scm |
| 489 |
(test-group "Test Zipf sampling" |
| 490 |
(reset-source!) |
| 491 |
(include "srfi-194-zipf-test.scm") |
| 492 |
(zipf-test-group)) |
| 493 |
|
| 494 |
(test-group "Test sphere" |
| 495 |
(include "srfi-194-sphere-test.scm") |
| 496 |
(reset-source!*) |
| 497 |
(test-sphere (make-sphere-generator 1) (vector 1.0 1.0) 200 #t) |
| 498 |
(test-sphere (make-sphere-generator 2) (vector 1.0 1.0 1.0) 200 #t) |
| 499 |
(test-sphere (make-sphere-generator 3) (vector 1.0 1.0 1.0 1.0) 200 #t) |
| 500 |
|
| 501 |
(reset-source!*) |
| 502 |
(test-sphere (make-ellipsoid-generator (vector 1.0 1.0)) (vector 1.0 1.0) 200 #t) |
| 503 |
(test-sphere (make-ellipsoid-generator (vector 1.0 1.0 1.0)) (vector 1.0 1.0 1.0) 200 #t) |
| 504 |
(test-sphere (make-ellipsoid-generator (vector 1.0 1.0 1.0 1.0)) (vector 1.0 1.0 1.0 1.0) 200 #t) |
| 505 |
|
| 506 |
(reset-source!*) |
| 507 |
(test-sphere (make-ellipsoid-generator (vector 1.0 3.0)) (vector 1.0 3.0) 200 #f) |
| 508 |
(test-sphere (make-ellipsoid-generator (vector 1.0 3.0 5.0)) (vector 1.0 3.0 5.0) 200 #f) |
| 509 |
(test-sphere (make-ellipsoid-generator (vector 1.0 3.0 5.0 7.0)) (vector 1.0 3.0 5.0 7.0) 200 #f) |
| 510 |
|
| 511 |
(reset-source!*) |
| 512 |
(test-ball (make-ball-generator 2) (vector 1.0 1.0)) |
| 513 |
(test-ball (make-ball-generator 3) (vector 1.0 1.0 1.0)) |
| 514 |
(test-ball (make-ball-generator (vector 1.0 3.0)) (vector 1.0 3.0)) |
| 515 |
(test-ball (make-ball-generator (vector 1.0 3.0 5.0)) (vector 1.0 3.0 5.0))) |
| 516 |
|
| 517 |
(test-group "Test binomial" |
| 518 |
(reset-source!) |
| 519 |
(define (factorial n) |
| 520 |
(if (<= n 1) |
| 521 |
1 |
| 522 |
(* n (factorial (- n 1))))) |
| 523 |
(define (C n k) |
| 524 |
(/ (factorial n) |
| 525 |
(* (factorial k) (factorial (- n k))))) |
| 526 |
(define (expected-frac n p k) |
| 527 |
(* (C n k) (expt p k) (expt (- 1 p) (- n k)))) |
| 528 |
|
| 529 |
(define (test-binomial n p count) |
| 530 |
(define g (make-binomial-generator n p)) |
| 531 |
(define counts (make-vector (+ n 1) 0)) |
| 532 |
(generator-for-each |
| 533 |
(lambda (x) |
| 534 |
(vector-set! counts x (+ 1 (vector-ref counts x)))) |
| 535 |
(gtake g count)) |
| 536 |
(for-each |
| 537 |
(lambda (k) |
| 538 |
(define expected (* count (expected-frac n p k) )) |
| 539 |
(define actual (vector-ref counts k)) |
| 540 |
(cond |
| 541 |
((= expected 0) |
| 542 |
(test-equal 0 actual)) |
| 543 |
;;hacky.. testing values with very low probability fails |
| 544 |
((> expected (* 1/1000 count)) |
| 545 |
(test-approximate 1.0 (/ actual expected) 0.2)))) |
| 546 |
(iota (+ n 1)))) |
| 547 |
|
| 548 |
(test-binomial 1 0 100) |
| 549 |
(test-binomial 1 1 100) |
| 550 |
(test-binomial 1 0. 100) |
| 551 |
(test-binomial 1 1. 100) |
| 552 |
(test-binomial 10 0 100) |
| 553 |
(test-binomial 10 1 100) |
| 554 |
(test-binomial 10 0. 100) |
| 555 |
(test-binomial 10 1. 100) |
| 556 |
(test-binomial 10 0.25 100000) |
| 557 |
(test-binomial 40 0.375 1000000)) |
| 558 |
|
| 559 |
|
| 560 |
(test-end "srfi-194") |