(use specialized-io numbers extras files)

;; With +max+ = 10000000 you'll get a
;; 500Mb file on the complex benchmark!
(define +max+ 1000000)

(define scheme-write-flonum-loop
  (lambda (port)
    (let ((x (exact->inexact (+ 2.0 (random +max+)))))
      (do ((i 0 (fx+ 1 i)))
          ((fx>= i +max+))
        (set! x (fp+ x (fp/ -0.8 x)))
        (write x port)
        (write-char #\space port)))))


(define scheme-write-fixnum-loop
  (lambda (port)
    (let ((x (+ 2 (random +max+))))
      (do ((i 0 (fx+ 1 i)))
          ((fx>= i +max+))
        (set! x (fx+ x (fx* -2 x)))
        (write x port)
        (write-char #\space port)))))


(define fast-write-fixnum-loop
  (lambda (port)
    (let ((x (+ 2 (random +max+))))
      (do ((i 0 (fx+ 1 i)))
          ((fx>= i +max+))
        (set! x (fx+ x (fx* -2 x)))
        (write-fixnum x port)
        (write-char #\space port)))))

(define fast-write-flonum-loop
  (lambda (port)
    (let ((x (exact->inexact (+ 2.0 (random +max+)))))
      (do ((i 0 (fx+ 1 i)))
          ((fx>= i +max+))
        (set! x (fp+ x (fp/ -0.8 x)))
        (write-flonum x port)
        (write-char #\space port)))))


(define scheme-read-fixnum-loop
  (lambda (port)
    (let ((sum 0)
          (sig 1))
      (do ((i 0 (fx+ 1 i)))
          ((>= i +max+) sum)
        (set! sum (fx+ sum (fx* (read port) sig)))
        (set! sig (fxneg sig))))))

(define scheme-read-flonum-loop
  (lambda (port)
    (let ((sum 0.0)
          (sig 1.0))
      (do ((i 0 (fx+ 1 i)))
          ((fx>= i +max+) sum)
        (set! sum (fp+ sum (fp* (read port) sig)))
        (set! sig (fpneg sig))))))


(define fast-read-fixnum-loop
  (lambda (port)
    (let ((sum 0)
          (sig 1))
      (do ((i 0 (fx+ 1 i)))
          ((>= i +max+) sum)
        (set! sum (fx+ sum (fx* (read-fixnum port) sig)))
        (set! sig (fxneg sig))))))

(define fast-read-flonum-loop
  (lambda (port)
    (let ((sum 0.0)
          (sig 1.0))
      (do ((i 0 (fx+ 1 i)))
          ((fx>= i +max+) sum)
        (set! sum (fp+ sum (fp* (read-flonum port) sig)))
        (set! sig (fpneg sig))))))


(define scheme-write-complex-loop
  (lambda (port)
    (let ((x (+ (make-rectangular 2.0 2.5) (exact->inexact (random +max+))))
          (y (make-rectangular -0.8 1)))
      (do ((i 0 (fx+ 1 i)))
          ((fx>= i +max+))
        (set! x (+ x (/ y x)))
        (write x port)
        (write-char #\space port)))))

(define scheme-read-complex-loop
  (lambda (port)
    (let ((sum 0.0)
          (sig 1.0))
      (do ((i 0 (fx+ 1 i)))
          ((fx>= i +max+) sum)
        (set! sum (+ sum (* (read port) sig)))
        (set! sig (fpneg sig))))))

(define fast-write-complex-loop
  (lambda (port)
    (let ((x (+ (make-rectangular 2.0 2.5) (exact->inexact (random +max+))))
          (y (make-rectangular -0.8 1)))
      (do ((i 0 (fx+ 1 i)))
          ((fx>= i +max+))
        (set! x (+ x (/ y x)))
        (write-complex x port)
        (write-char #\space port)))))

(define fast-read-complex-loop
  (lambda (port)
    (let ((sum 0.0)
          (sig 1.0))
      (do ((i 0 (fx+ 1 i)))
          ((fx>= i +max+) sum)
        (set! sum (+ sum (* (read-complex port) sig)))
        (set! sig (fpneg sig))))))


(define tempfile (create-temporary-file))
(let ((p (open-output-file tempfile)))
  (display "--- Below are times for scheme-write-fixnum: ")
  (newline)
  (time (scheme-write-fixnum-loop p))
  (display "--- Below are times for fast-write-fixnum: ")
  (newline)
  (time (fast-write-fixnum-loop p))
  (close-output-port p))

(newline)

(let ((p (open-input-file tempfile))
      (scheme-read-sum 0)
      (fast-read-sum 0))
  (display "--- Below are times for scheme-read-fixnum: ")
  (newline)
  (set! scheme-read-sum (time (scheme-read-fixnum-loop p)))
  (display "--- Below are times for fast-read-fixnum: ")
  (newline)
  (set! fast-read-sum (time (fast-read-fixnum-loop p)))
  (assert (= scheme-read-sum fast-read-sum))
  (display (format "(Both reading procedures returned ~a~%" scheme-read-sum))
  (close-input-port p))

(delete-file* tempfile)
(set! tempfile (create-temporary-file))

(newline)
(display "+++++++++++++++++++++++++++++++++++++++")
(newline)

(let ((p (open-output-file tempfile)))
  (display "--- Below are times for scheme-write-flonum: ")
  (newline)
  (time (scheme-write-flonum-loop p))
  (display "--- Below are times for fast-write-flonum: ")
  (newline)
  (time (fast-write-flonum-loop p))
  (close-output-port p))

(newline)

(let ((p (open-input-file tempfile))
      (scheme-read-sum 0.0)
      (fast-read-sum 0.0))
  (display "--- Below are times for scheme-read-flonum: ")
  (newline)
  (set! scheme-read-sum (time (scheme-read-flonum-loop p)))
  (display "--- Below are times for fast-read-flonum: ")
  (newline)
  (set! fast-read-sum (time (fast-read-flonum-loop p)))
  (assert (= scheme-read-sum fast-read-sum))
  (display (format "(Both reading procedures returned ~a~%" scheme-read-sum))
  (close-input-port p))

(delete-file* tempfile)
(set! tempfile (create-temporary-file))

(newline)
(display "+++++++++++++++++++++++++++++++++++++++")
(newline)

(let ((p (open-output-file tempfile)))
  (display "--- Below are times for scheme-write-complex: ")
  (newline)
  (time (scheme-write-complex-loop p))
  (display "--- Below are times for fast-write-complex: ")
  (newline)
  (time (fast-write-complex-loop p))
  (close-output-port p))

(newline)

(let ((p (open-input-file tempfile))
      (scheme-read-sum 0.0)
      (fast-read-sum 0.0))
  (display "--- Below are times for scheme-read-complex: ")
  (newline)
  (set! scheme-read-sum (time (scheme-read-complex-loop p)))
  (display "--- Below are times for fast-read-complex: ")
  (newline)
  (set! fast-read-sum (time (fast-read-complex-loop p)))
  (assert (= scheme-read-sum fast-read-sum))
  (display (format "(Both reading procedures returned ~a~%" scheme-read-sum))
  (close-input-port p))

(delete-file* tempfile)