Debian Codegraph @

test/include/srfi-194-test.scm

raw
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")