NoSyu의 주저리주저리 :: SICP Exercise 연습문제 3.76

이 문제는 연습문제 3.75에서 만든 프로시저가

모듈 방식을 따르지 않기에 모듈 방식에 맞출 수 있도록

두 원소의 평균 값들을 스트림으로 찍는 smooth 프로시저를 넣고 수정하는 문제입니다.

일단 결과는 잘 나옵니다.^^

그리고 어느 정도 모듈화에 성공한 듯싶습니다.

하지만 정말 이것이 맞는 정답인지는 잘 모르겠습니다.OTL....

참조

해럴드 애빌슨, 김재우 역, <컴퓨터 프로그램의 구조와 해석>, 인사이트, 2007, pp. 451

; stream
(define true (= 0 0))
(define false (= 1 0))

(define (cons-stream a b)
(cons a (delay b)))
(define the-empty-stream '())
(define stream-null? null?)
(define (stream-car stream) (car stream))
(define (stream-cdr stream) (force (cdr stream)))

; section 3.5
(define (stream-ref s n)
(if (= n 0)
(stream-car s)
(stream-ref (stream-cdr s) (- n 1))))

(define (stream-for-each proc s)
(if (stream-null? s)
      'done
      (begin (proc (stream-car s))
             (stream-for-each proc (stream-cdr s)))))

(define (display-stream s)
(stream-for-each display-line s))

(define (display-line x)
(newline)
(display x))

(define (stream-enumerate-interval low high)
(if (> low high)
      the-empty-stream
      (cons-stream
       low
       (stream-enumerate-interval (+ low 1) high))))

(define (stream-filter pred stream)
(cond ((stream-null? stream) the-empty-stream)
        ((pred (stream-car stream))
         (cons-stream (stream-car stream)
                      (stream-filter pred
                                     (stream-cdr stream))))
        (else (stream-filter pred (stream-cdr stream)))))

(define (memo-proc proc)
(let ((already-run? false) (result false))
    (lambda ()
      (if (not already-run?)
          (begin (set! result (proc))
                 (set! already-run? true)
                 result)
          result))))

(define (scale-stream stream factor)
(stream-map (lambda (x) (* x factor)) stream))

; exercise 3.50
(define (stream-map proc . argstreams)
(if (stream-null? (car argstreams))
      the-empty-stream
      (cons-stream
       (apply proc (map stream-car argstreams))
       (apply stream-map
              (cons proc (map stream-cdr argstreams))))))

;;;SECTION 3.5.2
(define (add-streams s1 s2)
(stream-map + s1 s2))

(define ones (cons-stream 1 ones))
(define integers (cons-stream 1 (add-streams ones integers)))

; exercise 3.54
(define (mul-streams s1 s2)
(stream-map * s1 s2))

; exercise 3.55
(define (partial-sums S)
(cons-stream (stream-car S) (add-streams (stream-cdr S)
(partial-sums S))))

; exercise 3.56
(define (merge s1 s2)
(cond ((stream-null? s1) s2)
        ((stream-null? s2) s1)
        (else
         (let ((s1car (stream-car s1))
               (s2car (stream-car s2)))
           (cond ((< s1car s2car)
                  (cons-stream s1car (merge (stream-cdr s1) s2)))
                 ((> s1car s2car)
                  (cons-stream s2car (merge s1 (stream-cdr s2))))
                 (else
                  (cons-stream s1car
                               (merge (stream-cdr s1)
                                      (stream-cdr s2)))))))))

; print-stream-n
(define (print-stream-n S n l)
(define (iter i)
    (if (= i n)
        'done
        (begin (display (stream-ref S i))
               (display "   ")
               (if (= (remainder (+ i 1) l) 0)
                   (newline))
               (iter (+ i 1)))))
(iter 0))

; exercise 3.59
(define (div-streams s1 s2)
(stream-map / s1 s2))

(define (integrate-series coff_stm)
(let ((integrate_s (cons-stream 1 ; 상수 c
(div-streams coff_stm integers))))
(stream-cdr integrate_s)))

(define exp-series
(cons-stream 1 (integrate-series exp-series)))
(define cosine-series
(cons-stream 1
(integrate-series (scale-stream sine-series -1))))
(define sine-series
(cons-stream 0
(integrate-series cosine-series)))

; exercise 3.60
(define (mul-series s1 s2)
(cons-stream (* (stream-car s1) (stream-car s2))
               (add-streams (mul-series (stream-cdr s1) s2)
                            (scale-stream (stream-cdr s2) (stream-car s1)))))
; exercise 3.61
(define (invert-unit-series S)
(define X
    (cons-stream 1
                 (scale-stream (mul-series (stream-cdr S) X) -1)))
X)

; exercise 3.62
; s1 / s2
(define (div-series s1 s2)
(if (= 0 (stream-car s2))
(error "Divide by zero" s2)
(mul-series s1 (invert-unit-series s2))))

; exercise 3.74
;(define (make-zero-crossings input-stream last-value)
; (cons-stream
;   (sign-change-detector (stream-car input-stream) last-value)
;   (make-zero-crossings (stream-cdr input-stream)
;                        (stream-car input-stream))))

(define zero-crossings (make-zero-crossings sense-data 0))

; make the procedure and stream
(define (sign-change-detector b a)
(let ((ab (* a b)))
    (cond ((< ab 0)
           (if (< a 0)
               1
               -1))
          ((= ab 0) ; 0은 양수로 취급.
           (if (= a 0)
               (sign-change-detector b 1)
               (sign-change-detector 1 a)))
          (else 0)))) ; ab > 0

(define sense-data
(cons-stream 1 (cons-stream 2 (cons-stream 1.5 (cons-stream 1 (cons-stream 0.5 (cons-stream -0.1 (cons-stream -2 (cons-stream -3 (cons-stream -2 (cons-stream -0.5 (cons-stream 0.2 (cons-stream 3 (cons-stream 4 sense-data))))))))))))))

; exercise 3.75
;(define (make-zero-crossings input-stream last-value last-avpt)
; (let ((avpt (/ (+ (stream-car input-stream) last-value) 2)))
;    (cons-stream (sign-change-detector avpt last-avpt)
;                 (make-zero-crossings (stream-cdr input-stream)
;                                      (stream-car input-stream)
;                                      avpt))))

; exercise 3.76
(define (smooth stm)
(let ((a (stream-car stm))
        (b (stream-car (stream-cdr stm))))
    (cons-stream (/ (+ a b) 2)
                 (smooth (stream-cdr stm)))))

(define (make-zero-crossings input-stream last-value)
(define (zero-crossing_s smooths)
    (let ((last-avpt (stream-car smooths))
          (avpt (stream-car (stream-cdr smooths))))
      (cons-stream (sign-change-detector avpt last-avpt)
                   (zero-crossing_s (stream-cdr smooths)))))
(zero-crossing_s (cons-stream last-value
                                (smooth input-stream))))

; execute
(print-stream-n zero-crossings 13 13)

크리에이티브 커먼즈 라이센스