#lang scheme

;; returns the closest number to X that has exactly DIGITS significant
;; figures.
(define (my-round x digits)

  ;; Returns a representation of x in scientific notation.  The
  ;; resulting values are the mantissa and the exponent.  So, for
  ;; example, (scientific 27) => (values 2.7 1), meaning that 27 is equal
  ;; to 2.7 times 10 ^ 1.

  (define (scientific x)
    (let loop ((mantissa x)
               (exponent 0))
      (if (or (zero? x)
              (and (>= (abs mantissa) 1)
                   (< (abs mantissa) 10)))
          (values mantissa exponent)
          (if (>= (abs mantissa) 10)
              (loop (/ mantissa 10)
                    (+ exponent 1))
              (loop (* mantissa 10)
                    (- exponent 1))))))

  (define (eggzackly x)
    (if (exact? x)
        x
      (inexact->exact x)))

  (let-values ([(mantissa exponent) (scientific x)])
    (* (eggzackly (round
                   (* mantissa (expt 10 (- digits 1)))))

       ;; You might be tempted to call `inexact->exact' on the return
       ;; from `expt' here, but that would be a mistake, because some
       ;; Schemes (such as Guile 1.3) don't have exact non-integers --
       ;; so that if, for example, `expt' returned 0.01,
       ;; `inexact->exact' on that value would yield zero instead of
       ;; 1/100.
       (expt 10 (+ exponent 1 (- digits))))))

(provide/contract [my-round (-> number? (and/c integer? positive? exact?) number?)])