source: project/release/4/lazy-lists/trunk/tests/run.scm @ 27153

Last change on this file since 27153 was 27153, checked in by juergen, 9 years ago

initial import

File size: 7.6 KB
Line 
1(require-library lazy-lists clojurian-syntax)
2(import lazy-lists clojurian-syntax)
3
4;;; (run xpr0 xpr1 ...)
5;;; -------------------
6(define (run . xprs)
7  (let loop ((xprs xprs))
8    (if (null? xprs)
9      (print "All tests passed!")
10      (if (car xprs)
11        (loop (cdr xprs))
12        (error 'run "#### Some test failed! ####")))))
13
14(define (cons-right var lst)
15  (if (null? lst)
16    (cons var lst)
17    (cons (car lst) (cons-right var (cdr lst)))))
18
19(define (Within eps seq)
20  (let loop ((seq seq))
21    (let ((a (Ref 0 seq)) (b (Ref 1 seq)))
22      (if (< (abs (- a b)) eps)
23        b
24        (loop (Rest seq))))))
25
26(define (Relative eps seq)
27  (let loop ((seq seq))
28    (let ((a (Ref 0 seq)) (b (Ref 1 seq)))
29      (if (<= (abs (/ a b)) (* (abs b) eps))
30        b
31        (loop (Rest seq))))))
32
33(define (Newton x) ; fixed point for square root
34  (lambda (a) (/ (+ a (/ x a)) 2))) 
35
36(define (Sums seq) ; List of sums
37  (letrec ((sums (Cons 0 (Map + seq (Lazy (Length seq) sums)))))
38    (Rest sums)))
39
40(define (First-five) (List 0 1 2 3 4))
41(define (Fibs)
42  (Append (List 0 1) (Lazy #f (Map + (Rest (Fibs)) (Fibs)))))
43
44;(define port (open-input-file "lazy-lists.scm"))
45;(define input (input->List port read-line))
46
47(run
48  (= (Length (First-five)) 5)
49  (= (Length (Rest (First-five))) 4)
50  (->> (Cardinals) (Rest) (Length) (eq? #f))
51  (->> (Cardinals) (Take 5) (Length) (= 5))
52  (->> (Cardinals) (Length) (eq? #f))
53  (->> (Cardinals) (Drop 5) (Length) (eq? #f))
54  (->> (Cardinals) (Drop 5) (First) (= 5))
55  (->> (First-five) (List->list) (equal? '(0 1 2 3 4)))
56  (->> (Cardinals) (Take 5) (List->list) (equal? '(0 1 2 3 4)))
57  (->> (Interval 2 10) (Length) (= (- 10 2)))
58  (->> (Interval 2 10) (List->list) (equal? '(2 3 4 5 6 7 8 9)))
59  (->> (Interval 10 2) (List->list) (equal? '(10 9 8 7 6 5 4 3)))
60  (equal?
61    (receive (head index tail) (Split-with (cut = <> 3) (First-five))
62      (cons (First tail) (List->list head)))
63    '(3 0 1 2))
64  (equal?
65    (receive (head index tail) (Split-with (cut = <> 5) (Take 10 (Cardinals)))
66      (append (List->list tail) (List->list head)))
67    '(5 6 7 8 9 0 1 2 3 4))
68  (->> (First-five) (Index (cut = <> 2)) (= 2))
69  (->> (First-five) (Index (cut = <> 20)) (= 5))
70  (->> (Cardinals) (Take 10) (Take-upto (cut = <> 5)) (List->list)
71       (equal? '(0 1 2 3 4)))
72  (->> (Cardinals) (Take 10) (Take-upto (cut = <> 5)) (Length) (= 5))
73  (->> (Cardinals) (Take 10) (Drop-upto (cut = <> 5)) (Length) (= 5))
74  (->> (Cardinals) (Take 10) (Drop-upto (cut = <> 5)) (First) (= 5))
75  (->> (First-five) (Drop-upto (cut = <> 2)) (Length) (= 3))
76  (->> (First-five) (Drop-upto (cut = <> 2)) (First) (= 2))
77  (->> (First-five) (Memp odd?) (List->list) (equal? '(1 2 3 4)))
78  (->> (Cardinals) (Take 10) (Memv 5) (List->list) (equal? '(5 6 7 8 9)))
79  (->> (Cardinals) (Map (lambda (x) (list x x))) (Take 10) (Assv 5)
80       (equal? '(5 5)))
81  (->> (First-five) (Map (lambda (x) (list x x))) (Assv 10)
82       (eq? #f))
83  (->> (Cardinals) (Equal? (Cardinals)) (eq? #f))
84  (->> (Cardinals) (Equal? (First-five)) (eq? #f))
85  (->> (First-five) (Equal? (First-five)) (eq? #t))
86  (->> (Cardinals) (Take 10) (Length) (= 10))
87  (->> (Cardinals) (Drop 1) (Filter odd?) (Take 5) (List->list)
88       (equal? '(1 3 5 7 9)))
89  (->> (Cardinals) (Length) (eq? #f))
90  (->> (First-five) (Map add1) (List->list) (equal? '(1 2 3 4 5)))
91  (->> (Map + (First-five) (Take 5 (Cardinals))) (List->list)
92       (equal? '(0 2 4 6 8)))
93  (->> (Map + (Cardinals) (Cardinals)) (Length) (eq? #f))
94  (->> (Filter odd? (First-five)) (Length) (= 2))
95  (->> (Filter odd? (First-five)) (List->list) (equal? '(1 3)))
96  (->> (Filter odd? (Cardinals)) (Length) (eq? #f))
97  (->> (Zip (Cardinals) (Cardinals)) (Sieve =) (Ref 20) (= 20))
98  (->> (Zip (First-five) (First-five)) (Sieve =) (List->list)
99       (equal? '(0 1 2 3 4)))
100  (->> (Ref 25 (Cardinals)) (= 25))
101  (->> (Ref 2 (First-five)) (= 2))
102  (->> (Repeat #f) (Take 3) (List->list) (equal? '(#f #f #f)))
103  (->> (Repeatedly (lambda () 1))(Take 3)  (List->list)
104       (equal? '(1 1 1)))
105  (->> (Iterate add1 0) (Take 3) (List->list) (equal? '(0 1 2)))
106  (->> (Iterate add1 0) (Length) (eq? #f))
107  (->> (Append (First-five) (First-five)) (Length) (= 10))
108  (->> (Append (First-five) (First-five)) (List->list)
109       (equal? '(0 1 2 3 4 0 1 2 3 4)))
110  (->> (Append (First-five) (Cardinals)) (Take 12) (List->list)
111       (equal? '(0 1 2 3 4 0 1 2 3 4 5 6)))
112  (->> (Append (First-five) (Cardinals)) (Length) (eq? #f))
113  (->> (First-five) (Reverse) (List->list) (equal? '(4 3 2 1 0)))
114  (->> (Cardinals) (Take 5) (Reverse) (List->list) (equal? '(4 3 2 1 0)))
115  (->> (First-five) (Reverse) (Length) (= 5))
116  (->> (Cardinals) (Reverse*) (Length) (eq? #f))
117  (->> (Cardinals) (Reverse*) (Ref 5) (List->list) (equal? '(5 4 3 2 1 0)))
118  (->> (Cycle (First-five)) (Take 10) (List->list)
119       (equal? '(0 1 2 3 4 0 1 2 3 4)))
120  (->> (Cycle (First-five)) (Length) (eq? #f))
121  (->> (Sort < (First-five)) (List->list) (equal? '(0 1 2 3 4)))
122  (->> (Sort < (First-five)) (Length) (= 5))
123  (->> (Sort < (List 3 1 0 2 4)) (List->list) (equal? '(0 1 2 3 4)))
124  (equal?
125    (receive (head tail) (Split-at 5 (Cardinals))
126      (cons (First tail) (List->list head)))
127    '(5 0 1 2 3 4))
128  (equal?
129    (receive (head tail) (Split-at 15 (Take 5 (Cardinals)))
130      (append (List->list tail) (List->list head)))
131    '(0 1 2 3 4))
132  (->> (Cardinals) (Take 5) (Fold-left + 0) (= 10))
133  (->> (Fold-left + 0 (First-five) (First-five)) (= 20))
134  (->> (List 1 2 3 4) (Fold-left * 1) (= 24))
135  (->> (Cardinals) (Take 5) (Fold-left cons '())
136       (equal? '(((((() . 0) . 1) . 2) . 3) . 4)))
137  (->> (Cardinals) (Fold-left* cons '()) (Ref 4)
138       (equal? '(((((() . 0) . 1) . 2) . 3) . 4)))
139  (->> (Cardinals) (Take 5) (Fold-right + 0) (= 10))
140  (->> (Fold-right + 0 (First-five) (First-five)) (= 20))
141  (->> (First-five) (Fold-right cons '())
142       (equal? '(0 1 2 3 4))) ; list
143  (->> (First-five) (Fold-right cons '(a b c))
144       (equal? '(0 1 2 3 4 a b c))) ; append
145  (->> (Cardinals) (Fold-right* cons '()) (Ref 4)
146       (equal? '(4 3 2 1 0))) ; note changed order
147  (->> (Cardinals) (Fold-right* cons-right '()) (Ref 4)
148       (equal? '(0 1 2 3 4)))
149  (->> (Cardinals) (Fold-right* cons '(a b c)) (Ref 4)
150       (equal? '(4 3 2 1 0 a b c))) ; note changed order
151  (->> (Cardinals) (Fold-right* cons-right '(a b c)) (Ref 4)
152       (equal? '(a b c 0 1 2 3 4)))
153  (->> (vector->List '#(0 1 2 3 4)) (List->list) (equal? '(0 1 2 3 4)))
154  (->> (vector->List '#()) (Null?))
155  (->> (Take 5 (Cardinals)) (List->vector) (equal? '#(0 1 2 3 4)))
156  (->> (List->vector (First-five)) (equal? '#(0 1 2 3 4)))
157  (->> (List->vector Nil) (equal? '#()))
158  (->> (Filter odd? (Cardinals)) (Take 15) (Every? odd?)
159       (eq? #t))
160  (->> (Take 15 (Cardinals)) (Every? odd?)
161       (eq? #f))
162  (->> (Every? odd? Nil) (eq? #t))
163  (->> (Some? odd? Nil) (eq? #f))
164  (->> (Filter even? (Cardinals)) (Take 5) (Some? odd?)
165       (eq? #f))
166  (->> (Some? odd? (First-five)) (eq? #t))
167  (->> (Zip (Cardinals) (First-five)) (Length) (eq? #f))
168  (->> (Zip (First-five) (Cardinals)) (Length) (eq? #f))
169  (->> (Zip (Cardinals) (Cardinals)) (Length) (eq? #f))
170  (->> (Zip (Cardinals) (First-five)) (Take 14)
171       (Eqv? (List 0 0 1 1 2 2 3 3 4 4 5 6 7 8)))
172  (->> (Zip (Cardinals) (Cardinals)) (Take 14)
173       (Eqv? (List 0 0 1 1 2 2 3 3 4 4 5 5 6 6)))
174  (->> (Zip (First-five) (First-five)) (Length) (= 10))
175  (->> (Zip (First-five) (First-five))
176       (Eqv? (List 0 0 1 1 2 2 3 3 4 4)))
177  (->> (Primes) (Ref 50) (= 233))
178  (->> (Primes) (Take 5) (Eqv? (List 2 3 5 7 11)))
179  (->> (Fibs) (Take 10) (Eqv? (List  0 1 1 2 3 5 8 13 21 34)))
180  ;; compute square root
181  (let ((eps 0.000001))
182    (< (abs (- (sqrt 2) (Within eps (Iterate (Newton 2) 2)))) eps))
183  (->> (First-five) (Sums) (List->list) (equal? '(0 1 3 6 10)))
184  )
185
Note: See TracBrowser for help on using the repository browser.