suzanne.soy/racket
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Got rid of assertions in the benchmarks caused by naturals as indices.

Browse Source
This commit is contained in:
Vincent St-Amour 2010-06-14 13:06:16 -04:00
parent 60c3067ddb
commit 7ccae0fb1d
11 changed files with 73 additions and 74 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

32
collects/tests/racket/benchmarks/common/typed/fft.rktl
View File

@ -27,16 +27,16 @@
(define (fft areal aimag)
(let: ((ar : (Vectorof Complex) (vector))
(ai : (Vectorof Complex) (vector))
(i : Natural 0)
(j : Natural 0)
(k : Natural 0)
(m : Natural 0)
(n : Natural 0)
(le : Natural 0)
(le1 : Natural 0)
(ip : Natural 0)
(nv2 : Natural 0)
(nm1 : Natural 0)
(i : Integer 0)
(j : Integer 0)
(k : Integer 0)
(m : Integer 0)
(n : Integer 0)
(le : Integer 0)
(le1 : Integer 0)
(ip : Integer 0)
(nv2 : Integer 0)
(nm1 : Integer 0)
(ur : Complex 0)
(ui : Complex 0)
(wr : Complex 0)
@ -47,9 +47,9 @@
(set! ar areal)
(set! ai aimag)
(set! n (vector-length ar))
(set! n (assert (- n 1) exact-nonnegative-integer?))
(set! n (- n 1))
(set! nv2 (quotient n 2))
(set! nm1 (assert (- n 1) exact-nonnegative-integer?))
(set! nm1 (- n 1))
(set! m 0) ;compute m = log(n)
(set! i 1)
(let loop ()
@ -74,7 +74,7 @@
(set! k nv2)
(let l6 ()
(cond ((< k j)
(set! j (assert (- j k) exact-nonnegative-integer?)) ; abs is to appease the typechecker
(set! j (- j k))
(set! k (quotient k 2))
(l6))))
(set! j (+ j k))
@ -92,11 +92,11 @@
(set! wi (sin (/ pi le1)))
;; loop thru butterflies
(do: : Void
((j : Natural 1 (+ j 1)))
((j : Integer 1 (+ j 1)))
((> j le1))
;; do a butterfly
(do: : Void
((i : Natural j (+ i le)))
((i : Integer j (+ i le)))
((> i n))
(set! ip (+ i le1))
(set! tr (- (* (vector-ref ar ip) ur)
@ -118,7 +118,7 @@
(: fft-bench ( -> Void))
(define (fft-bench)
(do: : Void
((ntimes : Natural 0 (+ ntimes 1)))
((ntimes : Integer 0 (+ ntimes 1)))
((= ntimes 5000))
(fft *re* *im*)))

30
collects/tests/racket/benchmarks/common/typed/paraffins.rktl
View File

@ -4,13 +4,13 @@
(: gen (Exact-Positive-Integer -> (Vectorof (Listof Radical))))
(define (gen n)
(let*: ((n/2 : Natural (quotient n 2))
(let*: ((n/2 : Integer (quotient n 2))
(radicals : (Vectorof (Listof Radical)) (make-vector (+ n/2 1) '(H))))
(: rads-of-size (Exact-Positive-Integer -> (Listof Radical)))
(define (rads-of-size n)
(let: loop1 : (Listof Radical)
((ps : (Listof (Vectorof Natural))
((ps : (Listof (Vectorof Integer))
(three-partitions (- n 1)))
(lst : (Listof Radical)
'()))
@ -55,7 +55,7 @@
(loop4 (cdr rads3)
lst))))))))))))
(: bcp-generator (Natural -> (Listof Radical)))
(: bcp-generator (Integer -> (Listof Radical)))
(define (bcp-generator j)
(if (odd? j)
'()
@ -82,7 +82,7 @@
(: ccp-generator (Exact-Positive-Integer -> (Listof Radical)))
(define (ccp-generator j)
(let: loop1 : (Listof Radical)
((ps : (Listof (Vectorof Natural))
((ps : (Listof (Vectorof Integer))
(four-partitions (- j 1)))
(lst : (Listof Radical)
'()))
@ -143,10 +143,10 @@
(vector-set! radicals i (rads-of-size i))
(loop (+ i 1)))))))
(: three-partitions (Natural -> (Listof (Vectorof Natural))))
(: three-partitions (Integer -> (Listof (Vectorof Integer))))
(define (three-partitions m)
(let: loop1 : (Listof (Vectorof Natural))
((lst : (Listof (Vectorof Natural)) '())
(let: loop1 : (Listof (Vectorof Integer))
((lst : (Listof (Vectorof Integer)) '())
(nc1 : Integer (quotient m 3)))
(if (< nc1 0)
lst
@ -157,14 +157,14 @@
(- nc1 1))
(loop2 (cons (vector nc1
nc2
(assert (- m (+ nc1 nc2)) exact-nonnegative-integer?))
(- m (+ nc1 nc2)))
lst)
(- nc2 1)))))))
(: four-partitions (Natural -> (Listof (Vectorof Natural))))
(: four-partitions (Integer -> (Listof (Vectorof Integer))))
(define (four-partitions m)
(let: loop1 : (Listof (Vectorof Natural))
((lst : (Listof (Vectorof Natural)) '())
(let: loop1 : (Listof (Vectorof Integer))
((lst : (Listof (Vectorof Integer)) '())
(nc1 : Integer (quotient m 4)))
(if (< nc1 0)
lst
@ -181,11 +181,11 @@
(loop3 (cons (vector nc1
nc2
nc3
(assert (- m (+ nc1 (+ nc2 nc3))) exact-nonnegative-integer?))
(- m (+ nc1 (+ nc2 nc3))))
lst)
(- nc3 1))))))))))
(: nb (Exact-Positive-Integer -> Natural))
(: nb (Exact-Positive-Integer -> Integer))
(define (nb n)
(let ((x (gen n)))
(+ (length (vector-ref x 0))
@ -193,8 +193,8 @@
(let ((input (with-input-from-file "input.txt" read)))
(time
(let: loop : Natural
((n : Natural 4000) (v : Natural 0))
(let: loop : Integer
((n : Integer 4000) (v : Integer 0))
(if (zero? n)
v
(loop (- n 1) (nb (if input 17 1)))))))

29
collects/tests/racket/benchmarks/shootout/typed/fannkuch.rktl
View File

@ -7,16 +7,16 @@
(require racket/cmdline)
(: fannkuch (Natural -> Natural))
(: fannkuch (Integer -> Integer))
(define (fannkuch n)
(let ([pi (list->vector
(for/list: : (Listof Natural) ([i : Natural (in-range n)]) i))]
(for/list: : (Listof Integer) ([i : Integer (in-range n)]) i))]
[tmp (make-vector n)]
[count (make-vector n)])
(let: loop : Natural
([flips : Natural 0]
[perms : Natural 0]
[r : Natural n])
(let: loop : Integer
([flips : Integer 0]
[perms : Integer 0]
[r : Integer n])
(when (< perms 30)
(for ([x (in-vector pi)])
(display (add1 x)))
@ -31,33 +31,32 @@
(for ([i (in-range r)])
(vector-set! pi i (vector-ref pi (add1 i))))
(vector-set! pi r perm0)
(vector-set! count r (assert (sub1 (vector-ref count r)) exact-nonnegative-integer?))
(vector-set! count r (sub1 (vector-ref count r)))
(cond
[(<= (vector-ref count r) 0)
(loop2 (add1 r))]
[else (loop flips2 (add1 perms) r)]))))))))
(: count-flips ((Vectorof Natural) (Vectorof Natural) -> Natural))
(: count-flips ((Vectorof Integer) (Vectorof Integer) -> Integer))
(define (count-flips pi rho)
(vector-copy! rho 0 pi)
(let: loop : Natural ([i : Natural 0])
(let: loop : Integer ([i : Integer 0])
(if (= (vector-ref rho 0) 0)
i
(begin
(vector-reverse-slice! rho 0 (add1 (vector-ref rho 0)))
(loop (add1 i))))))
(: vector-reverse-slice! (All (X) ((Vectorof X) Natural Natural -> Void)))
(: vector-reverse-slice! (All (X) ((Vectorof X) Integer Integer -> Void)))
(define (vector-reverse-slice! v i j)
(let: loop : Void
([i : Natural i]
[j : Natural (assert (sub1 j) exact-nonnegative-integer?)])
([i : Integer i]
[j : Integer (sub1 j)])
(when (> j i)
(vector-swap! v i j)
(loop (assert (add1 i) exact-nonnegative-integer?)
(assert (sub1 j) exact-nonnegative-integer?)))))
(loop (add1 i) (sub1 j)))))
(: vector-swap! (All (X) ((Vectorof X) Natural Natural -> Void)))
(: vector-swap! (All (X) ((Vectorof X) Integer Integer -> Void)))
(define (vector-swap! v i j)
(let ((t (vector-ref v i)))
(vector-set! v i (vector-ref v j))

20
collects/tests/racket/benchmarks/shootout/typed/heapsort.rktl
View File

@ -12,31 +12,31 @@
(define IA 3877)
(define IC 29573)
(: LAST Natural)
(: LAST Integer)
(define LAST 42)
(: gen_random (Float -> Float))
(define (gen_random max)
(set! LAST (modulo (+ (* LAST IA) IC) IM))
(/ (* max (exact->inexact LAST)) (exact->inexact IM)))
(: heapsort (Natural (Vectorof Float) -> (U Void True)))
(: heapsort (Integer (Vectorof Float) -> (U Void True)))
(define (heapsort n ra)
(let: ((ir : Natural n)
(l : Natural (+ (quotient n 2) 1))
(i : Natural 0)
(j : Natural 0)
(let: ((ir : Integer n)
(l : Integer (+ (quotient n 2) 1))
(i : Integer 0)
(j : Integer 0)
(rra : Float 0.0))
(let/ec: return : True
(do: : Void
((bar : True #t))
((= 1 0))
(cond ((> l 1)
(set! l (assert (- l 1) exact-nonnegative-integer?))
(set! l (- l 1))
(set! rra (vector-ref ra l)))
(else
(set! rra (vector-ref ra ir))
(vector-set! ra ir (vector-ref ra 1))
(set! ir (assert (- ir 1) exact-nonnegative-integer?))
(set! ir (- ir 1))
(cond ((<= ir 1)
(vector-set! ra 1 rra)
(return #t)))))
@ -56,11 +56,11 @@
(: main ((Vectorof String) -> Void))
(define (main args)
(let*: ((n : Natural
(let*: ((n : Integer
(or (and (= (vector-length args) 1)
(assert (string->number (vector-ref args 0)) exact-nonnegative-integer?))
1))
(last : Natural (+ n 1))
(last : Integer (+ n 1))
(ary : (Vectorof Float) (make-vector last 0.0)))
(do ((i 1 (+ i 1)))
((= i last))

2
collects/tests/racket/benchmarks/shootout/typed/mandelbrot.rktl
View File

@ -57,7 +57,7 @@
(begin
(when (positive? bitnum)
(write-byte (arithmetic-shift byteacc
(assert (- 8 (bitwise-and n #x7)) exact-nonnegative-integer?))
(- 8 (bitwise-and n #x7)))
out))
(loop-y (add1 y))))))))))

2
collects/tests/racket/benchmarks/shootout/typed/moments.rktl
View File

@ -46,7 +46,7 @@
(let* ((mid (quotient n 2))
(median (if (zero? (modulo n 2))
(/ (+ (car (list-tail numlist mid))
(car (list-tail numlist (assert (- mid 1) exact-nonnegative-integer?))))
(car (list-tail numlist (- mid 1))))
2.0)
(car (list-tail numlist mid))))
(standard_deviation (exact->inexact (/ (round (* standard_deviation 1000000))

2
collects/tests/racket/benchmarks/shootout/typed/nsievebits.rktl
View File

@ -54,7 +54,7 @@
(: string-pad (String Natural -> String))
(define (string-pad s len)
(string-append (make-string (assert (- len (string-length s)) exact-nonnegative-integer?) #\space)
(string-append (make-string (- len (string-length s)) #\space)
s))
(: test (Natural -> Void))

2
collects/tests/racket/benchmarks/shootout/typed/pidigits.rktl
View File

@ -45,7 +45,7 @@
(let-values ([(q r s t) (mk q r s t k)])
(digit (add1 k) q r s t n row col))))
(printf "~a\t:~a\n"
(make-string (assert (- 10 col) exact-nonnegative-integer?) #\space)
(make-string (- 10 col) #\space)
(+ row col))))
(: digits (Integer -> Void))

24
collects/tests/racket/benchmarks/shootout/typed/pidigits1.rktl
View File

@ -5,28 +5,28 @@
; This program is based on an implementation for SCM by Aubrey Jaffer and
; Jerry D. Hedden.
(: pi (Natural Natural -> Void))
(: pi (Integer Integer -> Void))
(define (pi n d)
(let*: ((r : Natural (assert (inexact->exact (floor (exp (* d (log 10))))) exact-nonnegative-integer?)) ; 10^d
(p : Natural (+ (quotient n d) 1))
(m : Natural (quotient (* p d 3322) 1000))
(a : (Vectorof Natural) (make-vector (+ m 1) 2))
(let*: ((r : Integer (floor (inexact->exact (exp (* d (log 10)))))) ; 10^d
(p : Integer (+ (quotient n d) 1))
(m : Integer (quotient (* p d 3322) 1000))
(a : (Vectorof Integer) (make-vector (+ m 1) 2))
(out : Output-Port (current-output-port)))
(vector-set! a m 4)
(let: j-loop : Void
([b : Natural 2][digits : Natural 0])
([b : Integer 2][digits : Integer 0])
(if (= digits n)
;; Add whitespace for ungenerated digits
(let ([left (modulo digits 10)])
(unless (zero? left)
(fprintf out "~a\t:~a\n" (make-string (assert (- 10 left) exact-nonnegative-integer?) #\space) n)))
(fprintf out "~a\t:~a\n" (make-string (- 10 left) #\space) n)))
;; Compute more digits
(let loop ([k m][q 0])
(let: loop : Void ([k : Integer m][q : Integer 0])
(if (zero? k)
(let* ((s (let ([s (number->string (+ b (quotient q r)))])
(if (zero? digits)
s
(string-append (make-string (assert (- d (string-length s)) exact-nonnegative-integer?) #\0) s)))))
(string-append (make-string (- d (string-length s)) #\0) s)))))
(j-loop (remainder q r)
(print-digits out s 0 (string-length s) digits n)))
(let ([q (+ q (* (vector-ref a k) r))])
@ -35,10 +35,10 @@
(vector-set! a k rr)
(loop (sub1 k) (* k qt)))))))))))
(: print-digits (Output-Port String Natural Natural Natural Natural -> Natural))
(: print-digits (Output-Port String Integer Integer Integer Integer -> Integer))
(define (print-digits out s start end digits n)
(let*: ([len : Natural (assert (- end start) exact-nonnegative-integer?)]
[cnt : Natural (assert (min len (- n digits) (- 10 (modulo digits 10)) len) exact-nonnegative-integer?)])
(let*: ([len : Integer (- end start)]
[cnt : Integer (min len (- n digits) (- 10 (modulo digits 10)) len)])
(if (zero? cnt)
digits
(begin

2
collects/tests/racket/benchmarks/shootout/typed/regexpdna.rktl
View File

@ -27,7 +27,7 @@
;; -------------------------------
(: match-count (Bytes Byte-Regexp Natural Natural -> Natural))
(: match-count (Bytes Byte-Regexp Integer Integer -> Integer))
(define (match-count str rx offset cnt)
(let ([m (regexp-match-positions rx str offset)])
(if m

2
collects/tests/racket/benchmarks/shootout/typed/wordfreq.rktl
View File

@ -29,7 +29,7 @@
(lambda: ((word : String) (count : Natural))
(let ((count (number->string count)))
(format"~a~a ~a~%"
(make-string (assert (- 7 (string-length count)) exact-nonnegative-integer?) #\space)
(make-string (- 7 (string-length count)) #\space)
count
word))))
string>?))