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

collects/tests/racket/benchmarks/common/typed/fft.rktl

@@ -27,16 +27,16 @@
 (define (fft areal aimag)
   (let: ((ar : (Vectorof Complex) (vector))
          (ai : (Vectorof Complex) (vector))
-         (i : Natural 0)
+         (i : Integer 0)
-         (j : Natural 0)
+         (j : Integer 0)
-         (k : Natural 0)
+         (k : Integer 0)
-         (m : Natural 0)
+         (m : Integer 0)
-         (n : Natural 0)
+         (n : Integer 0)
-         (le : Natural 0)
+         (le : Integer 0)
-         (le1 : Natural 0)
+         (le1 : Integer 0)
-         (ip : Natural 0)
+         (ip : Integer 0)
-         (nv2 : Natural 0)
+         (nv2 : Integer 0)
-         (nm1 : Natural 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*)))
 

collects/tests/racket/benchmarks/common/typed/paraffins.rktl

@@ -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))
+  (let: loop1 : (Listof (Vectorof Integer))
-        ((lst : (Listof (Vectorof Natural)) '())
+        ((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))
+  (let: loop1 : (Listof (Vectorof Integer))
-        ((lst : (Listof (Vectorof Natural)) '())
+        ((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
+   (let: loop : Integer
-         ((n : Natural 4000) (v : Natural 0))
+         ((n : Integer 4000) (v : Integer 0))
          (if (zero? n)
              v
              (loop (- n 1) (nb (if input 17 1)))))))

collects/tests/racket/benchmarks/shootout/typed/fannkuch.rktl

@@ -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
+    (let: loop : Integer
-          ([flips : Natural 0]
+          ([flips : Integer 0]
-           [perms : Natural 0]
+           [perms : Integer 0]
-           [r : Natural n])
+           [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]
+        ([i : Integer i]
-         [j : Natural (assert (sub1 j) exact-nonnegative-integer?)])
+         [j : Integer (sub1 j)])
     (when (> j i)
       (vector-swap! v i j)
-      (loop (assert (add1 i) exact-nonnegative-integer?)
+      (loop (add1 i) (sub1 j)))))
-            (assert (sub1 j) exact-nonnegative-integer?)))))
 
-(: 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))

collects/tests/racket/benchmarks/shootout/typed/heapsort.rktl

@@ -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)
+  (let: ((ir : Integer n)
-         (l : Natural (+ (quotient n 2) 1))
+         (l : Integer (+ (quotient n 2) 1))
-         (i : Natural 0)
+         (i : Integer 0)
-         (j : Natural 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))

collects/tests/racket/benchmarks/shootout/typed/mandelbrot.rktl

@@ -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))))))))))

collects/tests/racket/benchmarks/shootout/typed/moments.rktl

@@ -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))

collects/tests/racket/benchmarks/shootout/typed/nsievebits.rktl

@@ -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))

collects/tests/racket/benchmarks/shootout/typed/pidigits.rktl

@@ -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))

collects/tests/racket/benchmarks/shootout/typed/pidigits1.rktl

@@ -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
+  (let*: ((r : Integer (floor (inexact->exact (exp (* d (log 10)))))) ; 10^d
-          (p : Natural (+ (quotient n d) 1))
+          (p : Integer (+ (quotient n d) 1))
-          (m : Natural (quotient (* p d 3322) 1000))
+          (m : Integer (quotient (* p d 3322) 1000))
-          (a : (Vectorof Natural) (make-vector (+ m 1) 2))
+          (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?)]
+  (let*: ([len : Integer (- end start)]
-          [cnt : Natural (assert (min len (- n digits) (- 10 (modulo digits 10)) len) exact-nonnegative-integer?)])
+          [cnt : Integer (min len (- n digits) (- 10 (modulo digits 10)) len)])
     (if (zero? cnt)
         digits
         (begin

collects/tests/racket/benchmarks/shootout/typed/regexpdna.rktl

@@ -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

collects/tests/racket/benchmarks/shootout/typed/wordfreq.rktl

@@ -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>?))