(define (integer-fixed-point f guess prior-guess)
  (let ((next-guess (f guess)))
    (if (= next-guess prior-guess)
        guess
        (integer-fixed-point f next-guess guess))))

(define (average-damp f)
  (lambda (x) (quotient (+ x (f x)) 2)))

(define (bigsqrt x)
  (let* ((approximate-answer
          (integer-fixed-point
           (average-damp
            (lambda (y) (quotient x y))) 1 1))
         (error0 (abs (- x (* approximate-answer approximate-answer))))
         (error1 (abs (- x (* (+ approximate-answer 1)
                              (+ approximate-answer 1)))))
         (error2 (abs (- x (* (- approximate-answer 1)
                              (- approximate-answer 1))))))
    (cond ((and (< error0 error1)
                (< error0 error2)) approximate-answer)
          ((and (< error1 error0)
                (< error1 error2)) (+ approximate-answer 1))
          ((and (< error2 error0)
                (< error2 error1)) (- approximate-answer 1)))))

(define (thousand-digits)
  (let loop ((answer 0)
             (digits 0))
    (if (= digits 1000)
        answer
        (loop (+ (* answer 10) (random 10))
              (+ digits 1)))))

(define (check-answer number sqrt)
  (let ( (error0 (abs (- number (* sqrt sqrt))))
         (error1 (abs (- number (* (+ sqrt 1) (+ sqrt 1)))))
         (error2 (abs (- number (* (- sqrt 1) (- sqrt 1))))))
    (and (< error0 error1)
         (< error0 error2))))