Mercurial > lasercutter
comparison src/clojure/test_clojure/numbers.clj @ 10:ef7dbbd6452c
added clojure source goodness
author | Robert McIntyre <rlm@mit.edu> |
---|---|
date | Sat, 21 Aug 2010 06:25:44 -0400 |
parents | |
children |
comparison
equal
deleted
inserted
replaced
9:35cf337adfcf | 10:ef7dbbd6452c |
---|---|
1 ; Copyright (c) Rich Hickey. All rights reserved. | |
2 ; The use and distribution terms for this software are covered by the | |
3 ; Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php) | |
4 ; which can be found in the file epl-v10.html at the root of this distribution. | |
5 ; By using this software in any fashion, you are agreeing to be bound by | |
6 ; the terms of this license. | |
7 ; You must not remove this notice, or any other, from this software. | |
8 | |
9 ; Author: Stephen C. Gilardi | |
10 ;; scgilardi (gmail) | |
11 ;; Created 30 October 2008 | |
12 ;; | |
13 | |
14 (ns clojure.test-clojure.numbers | |
15 (:use clojure.test)) | |
16 | |
17 | |
18 ; TODO: | |
19 ; == | |
20 ; and more... | |
21 | |
22 | |
23 ;; *** Types *** | |
24 | |
25 (deftest Coerced-Byte | |
26 (let [v (byte 3)] | |
27 (are [x] (true? x) | |
28 (instance? Byte v) | |
29 (number? v) | |
30 (integer? v) | |
31 (rational? v)))) | |
32 | |
33 (deftest Coerced-Short | |
34 (let [v (short 3)] | |
35 (are [x] (true? x) | |
36 (instance? Short v) | |
37 (number? v) | |
38 (integer? v) | |
39 (rational? v)))) | |
40 | |
41 (deftest Coerced-Integer | |
42 (let [v (int 3)] | |
43 (are [x] (true? x) | |
44 (instance? Integer v) | |
45 (number? v) | |
46 (integer? v) | |
47 (rational? v)))) | |
48 | |
49 (deftest Coerced-Long | |
50 (let [v (long 3)] | |
51 (are [x] (true? x) | |
52 (instance? Long v) | |
53 (number? v) | |
54 (integer? v) | |
55 (rational? v)))) | |
56 | |
57 (deftest Coerced-BigInteger | |
58 (let [v (bigint 3)] | |
59 (are [x] (true? x) | |
60 (instance? BigInteger v) | |
61 (number? v) | |
62 (integer? v) | |
63 (rational? v)))) | |
64 | |
65 (deftest Coerced-Float | |
66 (let [v (float 3)] | |
67 (are [x] (true? x) | |
68 (instance? Float v) | |
69 (number? v) | |
70 (float? v)))) | |
71 | |
72 (deftest Coerced-Double | |
73 (let [v (double 3)] | |
74 (are [x] (true? x) | |
75 (instance? Double v) | |
76 (number? v) | |
77 (float? v)))) | |
78 | |
79 (deftest Coerced-BigDecimal | |
80 (let [v (bigdec 3)] | |
81 (are [x] (true? x) | |
82 (instance? BigDecimal v) | |
83 (number? v) | |
84 (decimal? v) | |
85 (not (float? v))))) | |
86 | |
87 | |
88 ;; *** Functions *** | |
89 | |
90 (defonce DELTA 1e-12) | |
91 | |
92 (deftest test-add | |
93 (are [x y] (= x y) | |
94 (+) 0 | |
95 (+ 1) 1 | |
96 (+ 1 2) 3 | |
97 (+ 1 2 3) 6 | |
98 | |
99 (+ -1) -1 | |
100 (+ -1 -2) -3 | |
101 (+ -1 +2 -3) -2 | |
102 | |
103 (+ 1 -1) 0 | |
104 (+ -1 1) 0 | |
105 | |
106 (+ 2/3) 2/3 | |
107 (+ 2/3 1) 5/3 | |
108 (+ 2/3 1/3) 1 ) | |
109 | |
110 (are [x y] (< (- x y) DELTA) | |
111 (+ 1.2) 1.2 | |
112 (+ 1.1 2.4) 3.5 | |
113 (+ 1.1 2.2 3.3) 6.6 ) | |
114 | |
115 (is (> (+ Integer/MAX_VALUE 10) Integer/MAX_VALUE)) ; no overflow | |
116 (is (thrown? ClassCastException (+ "ab" "cd"))) ) ; no string concatenation | |
117 | |
118 | |
119 (deftest test-subtract | |
120 (is (thrown? IllegalArgumentException (-))) | |
121 (are [x y] (= x y) | |
122 (- 1) -1 | |
123 (- 1 2) -1 | |
124 (- 1 2 3) -4 | |
125 | |
126 (- -2) 2 | |
127 (- 1 -2) 3 | |
128 (- 1 -2 -3) 6 | |
129 | |
130 (- 1 1) 0 | |
131 (- -1 -1) 0 | |
132 | |
133 (- 2/3) -2/3 | |
134 (- 2/3 1) -1/3 | |
135 (- 2/3 1/3) 1/3 ) | |
136 | |
137 (are [x y] (< (- x y) DELTA) | |
138 (- 1.2) -1.2 | |
139 (- 2.2 1.1) 1.1 | |
140 (- 6.6 2.2 1.1) 3.3 ) | |
141 | |
142 (is (< (- Integer/MIN_VALUE 10) Integer/MIN_VALUE)) ) ; no underflow | |
143 | |
144 | |
145 (deftest test-multiply | |
146 (are [x y] (= x y) | |
147 (*) 1 | |
148 (* 2) 2 | |
149 (* 2 3) 6 | |
150 (* 2 3 4) 24 | |
151 | |
152 (* -2) -2 | |
153 (* 2 -3) -6 | |
154 (* 2 -3 -1) 6 | |
155 | |
156 (* 1/2) 1/2 | |
157 (* 1/2 1/3) 1/6 | |
158 (* 1/2 1/3 -1/4) -1/24 ) | |
159 | |
160 (are [x y] (< (- x y) DELTA) | |
161 (* 1.2) 1.2 | |
162 (* 2.0 1.2) 2.4 | |
163 (* 3.5 2.0 1.2) 8.4 ) | |
164 | |
165 (is (> (* 3 (int (/ Integer/MAX_VALUE 2.0))) Integer/MAX_VALUE)) ) ; no overflow | |
166 | |
167 (deftest test-ratios-simplify-to-ints-where-appropriate | |
168 (testing "negative denominator (assembla #275)" | |
169 (is (integer? (/ 1 -1/2))) | |
170 (is (integer? (/ 0 -1/2))))) | |
171 | |
172 (deftest test-divide | |
173 (are [x y] (= x y) | |
174 (/ 1) 1 | |
175 (/ 2) 1/2 | |
176 (/ 3 2) 3/2 | |
177 (/ 4 2) 2 | |
178 (/ 24 3 2) 4 | |
179 (/ 24 3 2 -1) -4 | |
180 | |
181 (/ -1) -1 | |
182 (/ -2) -1/2 | |
183 (/ -3 -2) 3/2 | |
184 (/ -4 -2) 2 | |
185 (/ -4 2) -2 ) | |
186 | |
187 (are [x y] (< (- x y) DELTA) | |
188 (/ 4.5 3) 1.5 | |
189 (/ 4.5 3.0 3.0) 0.5 ) | |
190 | |
191 (is (thrown? ArithmeticException (/ 0))) | |
192 (is (thrown? ArithmeticException (/ 2 0))) | |
193 (is (thrown? IllegalArgumentException (/))) ) | |
194 | |
195 | |
196 ;; mod | |
197 ;; http://en.wikipedia.org/wiki/Modulo_operation | |
198 ;; http://mathforum.org/library/drmath/view/52343.html | |
199 ;; | |
200 ;; is mod correct? | |
201 ;; http://groups.google.com/group/clojure/browse_frm/thread/2a0ee4d248f3d131# | |
202 ;; | |
203 ;; Issue 23: mod (modulo) operator | |
204 ;; http://code.google.com/p/clojure/issues/detail?id=23 | |
205 | |
206 (deftest test-mod | |
207 ; wrong number of args | |
208 (is (thrown? IllegalArgumentException (mod))) | |
209 (is (thrown? IllegalArgumentException (mod 1))) | |
210 (is (thrown? IllegalArgumentException (mod 3 2 1))) | |
211 | |
212 ; divide by zero | |
213 (is (thrown? ArithmeticException (mod 9 0))) | |
214 (is (thrown? ArithmeticException (mod 0 0))) | |
215 | |
216 (are [x y] (= x y) | |
217 (mod 4 2) 0 | |
218 (mod 3 2) 1 | |
219 (mod 6 4) 2 | |
220 (mod 0 5) 0 | |
221 | |
222 (mod 2 1/2) 0 | |
223 (mod 2/3 1/2) 1/6 | |
224 (mod 1 2/3) 1/3 | |
225 | |
226 (mod 4.0 2.0) 0.0 | |
227 (mod 4.5 2.0) 0.5 | |
228 | |
229 ; |num| > |div|, num != k * div | |
230 (mod 42 5) 2 ; (42 / 5) * 5 + (42 mod 5) = 8 * 5 + 2 = 42 | |
231 (mod 42 -5) -3 ; (42 / -5) * (-5) + (42 mod -5) = -9 * (-5) + (-3) = 42 | |
232 (mod -42 5) 3 ; (-42 / 5) * 5 + (-42 mod 5) = -9 * 5 + 3 = -42 | |
233 (mod -42 -5) -2 ; (-42 / -5) * (-5) + (-42 mod -5) = 8 * (-5) + (-2) = -42 | |
234 | |
235 ; |num| > |div|, num = k * div | |
236 (mod 9 3) 0 ; (9 / 3) * 3 + (9 mod 3) = 3 * 3 + 0 = 9 | |
237 (mod 9 -3) 0 | |
238 (mod -9 3) 0 | |
239 (mod -9 -3) 0 | |
240 | |
241 ; |num| < |div| | |
242 (mod 2 5) 2 ; (2 / 5) * 5 + (2 mod 5) = 0 * 5 + 2 = 2 | |
243 (mod 2 -5) -3 ; (2 / -5) * (-5) + (2 mod -5) = (-1) * (-5) + (-3) = 2 | |
244 (mod -2 5) 3 ; (-2 / 5) * 5 + (-2 mod 5) = (-1) * 5 + 3 = -2 | |
245 (mod -2 -5) -2 ; (-2 / -5) * (-5) + (-2 mod -5) = 0 * (-5) + (-2) = -2 | |
246 | |
247 ; num = 0, div != 0 | |
248 (mod 0 3) 0 ; (0 / 3) * 3 + (0 mod 3) = 0 * 3 + 0 = 0 | |
249 (mod 0 -3) 0 | |
250 ) | |
251 ) | |
252 | |
253 ;; rem & quot | |
254 ;; http://en.wikipedia.org/wiki/Remainder | |
255 | |
256 (deftest test-rem | |
257 ; wrong number of args | |
258 (is (thrown? IllegalArgumentException (rem))) | |
259 (is (thrown? IllegalArgumentException (rem 1))) | |
260 (is (thrown? IllegalArgumentException (rem 3 2 1))) | |
261 | |
262 ; divide by zero | |
263 (is (thrown? ArithmeticException (rem 9 0))) | |
264 (is (thrown? ArithmeticException (rem 0 0))) | |
265 | |
266 (are [x y] (= x y) | |
267 (rem 4 2) 0 | |
268 (rem 3 2) 1 | |
269 (rem 6 4) 2 | |
270 (rem 0 5) 0 | |
271 | |
272 (rem 2 1/2) 0 | |
273 (rem 2/3 1/2) 1/6 | |
274 (rem 1 2/3) 1/3 | |
275 | |
276 (rem 4.0 2.0) 0.0 | |
277 (rem 4.5 2.0) 0.5 | |
278 | |
279 ; |num| > |div|, num != k * div | |
280 (rem 42 5) 2 ; (8 * 5) + 2 == 42 | |
281 (rem 42 -5) 2 ; (-8 * -5) + 2 == 42 | |
282 (rem -42 5) -2 ; (-8 * 5) + -2 == -42 | |
283 (rem -42 -5) -2 ; (8 * -5) + -2 == -42 | |
284 | |
285 ; |num| > |div|, num = k * div | |
286 (rem 9 3) 0 | |
287 (rem 9 -3) 0 | |
288 (rem -9 3) 0 | |
289 (rem -9 -3) 0 | |
290 | |
291 ; |num| < |div| | |
292 (rem 2 5) 2 | |
293 (rem 2 -5) 2 | |
294 (rem -2 5) -2 | |
295 (rem -2 -5) -2 | |
296 | |
297 ; num = 0, div != 0 | |
298 (rem 0 3) 0 | |
299 (rem 0 -3) 0 | |
300 ) | |
301 ) | |
302 | |
303 (deftest test-quot | |
304 ; wrong number of args | |
305 (is (thrown? IllegalArgumentException (quot))) | |
306 (is (thrown? IllegalArgumentException (quot 1))) | |
307 (is (thrown? IllegalArgumentException (quot 3 2 1))) | |
308 | |
309 ; divide by zero | |
310 (is (thrown? ArithmeticException (quot 9 0))) | |
311 (is (thrown? ArithmeticException (quot 0 0))) | |
312 | |
313 (are [x y] (= x y) | |
314 (quot 4 2) 2 | |
315 (quot 3 2) 1 | |
316 (quot 6 4) 1 | |
317 (quot 0 5) 0 | |
318 | |
319 (quot 2 1/2) 4 | |
320 (quot 2/3 1/2) 1 | |
321 (quot 1 2/3) 1 | |
322 | |
323 (quot 4.0 2.0) 2.0 | |
324 (quot 4.5 2.0) 2.0 | |
325 | |
326 ; |num| > |div|, num != k * div | |
327 (quot 42 5) 8 ; (8 * 5) + 2 == 42 | |
328 (quot 42 -5) -8 ; (-8 * -5) + 2 == 42 | |
329 (quot -42 5) -8 ; (-8 * 5) + -2 == -42 | |
330 (quot -42 -5) 8 ; (8 * -5) + -2 == -42 | |
331 | |
332 ; |num| > |div|, num = k * div | |
333 (quot 9 3) 3 | |
334 (quot 9 -3) -3 | |
335 (quot -9 3) -3 | |
336 (quot -9 -3) 3 | |
337 | |
338 ; |num| < |div| | |
339 (quot 2 5) 0 | |
340 (quot 2 -5) 0 | |
341 (quot -2 5) 0 | |
342 (quot -2 -5) 0 | |
343 | |
344 ; num = 0, div != 0 | |
345 (quot 0 3) 0 | |
346 (quot 0 -3) 0 | |
347 ) | |
348 ) | |
349 | |
350 | |
351 ;; *** Predicates *** | |
352 | |
353 ;; pos? zero? neg? | |
354 | |
355 (deftest test-pos?-zero?-neg? | |
356 (let [nums [[(byte 2) (byte 0) (byte -2)] | |
357 [(short 3) (short 0) (short -3)] | |
358 [(int 4) (int 0) (int -4)] | |
359 [(long 5) (long 0) (long -5)] | |
360 [(bigint 6) (bigint 0) (bigint -6)] | |
361 [(float 7) (float 0) (float -7)] | |
362 [(double 8) (double 0) (double -8)] | |
363 [(bigdec 9) (bigdec 0) (bigdec -9)] | |
364 [2/3 0 -2/3]] | |
365 pred-result [[pos? [true false false]] | |
366 [zero? [false true false]] | |
367 [neg? [false false true]]] ] | |
368 (doseq [pr pred-result] | |
369 (doseq [n nums] | |
370 (is (= (map (first pr) n) (second pr)) | |
371 (pr-str (first pr) n)))))) | |
372 | |
373 | |
374 ;; even? odd? | |
375 | |
376 (deftest test-even? | |
377 (are [x] (true? x) | |
378 (even? -4) | |
379 (not (even? -3)) | |
380 (even? 0) | |
381 (not (even? 5)) | |
382 (even? 8)) | |
383 (is (thrown? ArithmeticException (even? 1/2))) | |
384 (is (thrown? ArithmeticException (even? (double 10))))) | |
385 | |
386 (deftest test-odd? | |
387 (are [x] (true? x) | |
388 (not (odd? -4)) | |
389 (odd? -3) | |
390 (not (odd? 0)) | |
391 (odd? 5) | |
392 (not (odd? 8))) | |
393 (is (thrown? ArithmeticException (odd? 1/2))) | |
394 (is (thrown? ArithmeticException (odd? (double 10))))) | |
395 | |
396 (defn- expt | |
397 "clojure.contrib.math/expt is a better and much faster impl, but this works. | |
398 Math/pow overflows to Infinity." | |
399 [x n] (apply * (replicate n x))) | |
400 | |
401 (deftest test-bit-shift-left | |
402 (are [x y] (= x y) | |
403 2r10 (bit-shift-left 2r1 1) | |
404 2r100 (bit-shift-left 2r1 2) | |
405 2r1000 (bit-shift-left 2r1 3) | |
406 2r00101110 (bit-shift-left 2r00010111 1) | |
407 2r00101110 (apply bit-shift-left [2r00010111 1]) | |
408 2r01 (bit-shift-left 2r10 -1) | |
409 (expt 2 32) (bit-shift-left 1 32) | |
410 (expt 2 10000) (bit-shift-left 1 10000) | |
411 )) | |
412 | |
413 (deftest test-bit-shift-right | |
414 (are [x y] (= x y) | |
415 2r0 (bit-shift-right 2r1 1) | |
416 2r010 (bit-shift-right 2r100 1) | |
417 2r001 (bit-shift-right 2r100 2) | |
418 2r000 (bit-shift-right 2r100 3) | |
419 2r0001011 (bit-shift-right 2r00010111 1) | |
420 2r0001011 (apply bit-shift-right [2r00010111 1]) | |
421 2r100 (bit-shift-right 2r10 -1) | |
422 1 (bit-shift-right (expt 2 32) 32) | |
423 1 (bit-shift-right (expt 2 10000) 10000) | |
424 )) | |
425 | |
426 | |
427 ;; arrays | |
428 (deftest test-array-types | |
429 (are [x y z] (= (Class/forName x) (class y) (class z)) | |
430 "[Z" (boolean-array 1) (booleans (boolean-array 1 true)) | |
431 "[B" (byte-array 1) (bytes (byte-array 1 (byte 1))) | |
432 "[C" (char-array 1) (chars (char-array 1 \a)) | |
433 "[S" (short-array 1) (shorts (short-array 1 (short 1))) | |
434 "[F" (float-array 1) (floats (float-array 1 1)) | |
435 "[D" (double-array 1) (doubles (double-array 1 1)) | |
436 "[I" (int-array 1) (ints (int-array 1 1)) | |
437 "[J" (long-array 1) (longs (long-array 1 1)))) | |
438 | |
439 | |
440 (deftest test-ratios | |
441 (is (= (denominator 1/2) 2)) | |
442 (is (= (numerator 1/2) 1)) | |
443 (is (= (bigint (/ 100000000000000000000 3)) 33333333333333333333)) | |
444 (is (= (long 10000000000000000000/3) 3333333333333333333))) |