AtlatestRepositorysigil-geometry

sigil-geometry / tree / testtest-properties.sgl

1;;; Property tests over deterministic pseudo-random inputs.
2;;;
3;;; A MINSTD generator with a fixed seed, so a failure reproduces
4;;; exactly. Each property runs over 200 cases and reports the first
5;;; failing case's inputs.
6
7(import (sigil test)
8 (sigil geometry))
9
10(define cases 200)
12;; MINSTD: s' = s * 48271 mod (2^31 - 1)
13(define seed 20260925)
14(define (next-unit!)
15 (set! seed (modulo (* seed 48271) 2147483647))
16 (/ seed 2147483647.0))
18;; uniform in [lo, hi)
19(define (uniform lo hi) (+ lo (* (- hi lo) (next-unit!))))
21(define (random-vec3 r) (vec3 (uniform (- r) r) (uniform (- r) r) (uniform (- r) r)))
23;; A unit quaternion from a random vec4, skipping near-zero draws.
24(define (random-quat)
25 (let ((q (quat (uniform -1 1) (uniform -1 1) (uniform -1 1) (uniform -1 1))))
26 (if (< (quat-length q) 0.1)
27 (random-quat)
28 (quat-normalize q))))
30;; A well-conditioned model matrix: translation within 10, any rotation,
31;; scale between 0.5 and 2 on each axis.
32(define (random-trs)
33 (mat4-from-trs (random-vec3 10)
34 (random-quat)
35 (vec3 (uniform 0.5 2) (uniform 0.5 2) (uniform 0.5 2))))
37(define (random-mat4)
38 (let ((m (make-mat4)))
39 (let loop ((i 0))
40 (when (< i 16)
41 (bytevector-ieee-single-set! m (* 4 i) (uniform -3 3))
42 (loop (+ i 1))))
43 m))
45;; Run `check` on `cases` generated inputs; fail with the first bad input.
46(define (for-all generate check)
47 (let loop ((i 0))
48 (when (< i cases)
49 (let ((input (generate)))
50 (if (check input)
51 (loop (+ i 1))
52 (assert-equal (list 'case i 'holds) (list 'case i 'fails-for input)))))))
54(define eps 1e-4)
56(test-group "matrix properties"
57 (test "inverse * m = identity and m * inverse = identity"
58 (for-all random-trs
59 (lambda (m)
60 (let ((inv (mat4-inverse m)))
61 (and inv
62 (mat4-approx=? (make-mat4) (mat4-mul inv m) eps)
63 (mat4-approx=? (make-mat4) (mat4-mul m inv) eps))))))
65 (test "inverse of a general matrix, when it has one"
66 ;; Near-singular draws amplify float32 error, so only draws with
67 ;; |det| >= 0.5 are held to the bound. `checked` counts them, and a
68 ;; floor makes sure the property did not pass by skipping everything.
69 (let ((checked 0))
70 (for-all random-mat4
71 (lambda (m)
72 (let ((inv (mat4-inverse m)))
73 (or (not inv)
74 (< (abs (mat4-determinant m)) 0.5)
75 (begin
76 (set! checked (+ checked 1))
77 (mat4-approx=? (make-mat4) (mat4-mul inv m) 1e-3))))))
78 (assert-true (>= checked 100))))
80 (test "mat3 inverse * m = identity"
81 (for-all (lambda () (mat3-from-mat4 (random-trs)))
82 (lambda (m)
83 (mat3-approx=? (make-mat3) (mat3-mul (mat3-inverse m) m) eps))))
85 (test "transforming by a product equals transforming twice"
86 (for-all (lambda () (list (random-trs) (random-trs) (random-vec3 5)))
87 (lambda (in)
88 (let ((a (car in)) (b (cadr in)) (p (caddr in)))
89 (vec3-approx=? (mat4-transform-point (mat4-mul a b) p)
90 (mat4-transform-point a (mat4-transform-point b p))
91 eps)))))
93 (test "the transpose of a product is the product of transposes, reversed"
94 (for-all (lambda () (list (random-mat4) (random-mat4)))
95 (lambda (in)
96 (let ((a (car in)) (b (cadr in)))
97 (mat4-approx=? (mat4-transpose (mat4-mul a b))
98 (mat4-mul (mat4-transpose b) (mat4-transpose a))
99 eps))))))
101(test-group "quaternion properties"
102 (test "quat -> mat4 -> quat is the same rotation"
103 (for-all random-quat
104 (lambda (q) (quat-same-rotation? q (quat-from-mat4 (mat4-from-quat q)) eps))))
106 (test "quat -> mat3 -> quat is the same rotation"
107 (for-all random-quat
108 (lambda (q) (quat-same-rotation? q (quat-from-mat3 (mat3-from-quat q)) eps))))
110 (test "rotating by q equals transforming by its matrix"
111 (for-all (lambda () (cons (random-quat) (random-vec3 5)))
112 (lambda (in)
113 (vec3-approx=? (quat-rotate-vec3 (car in) (cdr in))
114 (mat4-transform-direction (mat4-from-quat (car in)) (cdr in))
115 eps))))
117 (test "rotation keeps length"
118 (for-all (lambda () (cons (random-quat) (random-vec3 5)))
119 (lambda (in)
120 (float-approx=? (vec3-length (cdr in))
121 (vec3-length (quat-rotate-vec3 (car in) (cdr in)))
122 eps))))
124 (test "slerp stays unit length and moves at constant angle"
125 (for-all (lambda () (list (random-quat) (random-quat) (uniform 0 1)))
126 (lambda (in)
127 (let* ((a (car in)) (b (cadr in)) (t (caddr in))
128 (s (quat-slerp a b t))
129 (total (quat-angle (quat-mul (quat-conjugate a) b)))
130 (part (quat-angle (quat-mul (quat-conjugate a) s))))
131 (and (float-approx=? 1.0 (quat-length s) eps)
132 (< (abs (- part (* t total))) 1e-3)))))))
134(test-group "! forms agree with allocating forms, with dst aliased"
135 (test "mat4-mul! into either input"
136 (for-all (lambda () (list (random-mat4) (random-mat4)))
137 (lambda (in)
138 (let* ((a (car in)) (b (cadr in)) (expected (mat4-mul a b))
139 (a2 (mat4-copy a)) (b2 (mat4-copy b)))
140 (mat4-mul! a2 a2 b)
141 (mat4-mul! b2 a b2)
142 (and (mat4-approx=? expected a2 eps) (mat4-approx=? expected b2 eps))))))
144 (test "mat4-inverse! and mat3-inverse! in place"
145 (for-all random-trs
146 (lambda (m)
147 (let ((expected (mat4-inverse m)) (m2 (mat4-copy m))
148 (n (mat3-from-mat4 m)))
149 (mat4-inverse! m2 m2)
150 (let ((n-expected (mat3-inverse n)))
151 (mat3-inverse! n n)
152 (and (mat4-approx=? expected m2 eps)
153 (mat3-approx=? n-expected n eps)))))))
155 (test "quat-mul!, quat-slerp! and vec3-cross! in place"
156 (for-all (lambda () (list (random-quat) (random-quat) (random-vec3 3) (random-vec3 3)))
157 (lambda (in)
158 (let* ((qa (car in)) (qb (cadr in)) (u (caddr in)) (v (cadddr in))
159 (mul (quat-mul qa qb)) (sl (quat-slerp qa qb 0.3)) (cr (vec3-cross u v))
160 (qa2 (quat-copy qa)) (qb2 (quat-copy qb)) (u2 (vec3-copy u)))
161 (quat-mul! qa2 qa2 qb)
162 (quat-slerp! qb2 qa qb2 0.3)
163 (vec3-cross! u2 u2 v)
164 (and (quat-approx=? mul qa2 eps)
165 (quat-approx=? sl qb2 eps)
166 (vec3-approx=? cr u2 eps)))))))