책에 소개된 세 가지 방법 모두를 해보고 그 시간 차이를 알아보는 것입니다.

전에 측정하였던 방법으로 해보았으나 잘 되지 않아 조금 무식하게 해보았습니다.^^

그 차이를 보면 가속기를 쓰지 않으면 대략 70초 가량이 걸립니다.

그리고 오일러 가속기를 쓰게 되면 10ms정도,

태블로(tableau)를 이용하면 그보다 더 빠르게 수행 결과를 내놓는 것을 알 수 있습니다.

하지만 그 결과값은 각각 다릅니다.

왜 그러한지는 잘 모르겠습니다.OTL....

참조

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

; 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)
  (define (iter i)
    (if (= i n)
        'done
        (begin (display (stream-ref S i))
               (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.63
(define (sqrt-improve guess x)
  (average guess (/ x guess)))

(define (average x y)
  (/ (+ x y) 2))

(define (sqrt-stream x)
  (define guesses
    (cons-stream 1.0
                 (stream-map (lambda (guess)
                               (sqrt-improve guess x))
                             guesses)))
  guesses)

; exercise 3.64
(define (stream-limit stm tolerance)
  (let ((element1 (stream-car stm)) ; 앞의 원소
        (element2 (stream-car (stream-cdr stm)))) ; 뒤의 원소
    (if (< (abs (- element1 element2)) tolerance)
        element2
        (stream-limit (stream-cdr stm) tolerance))))
(define (sqrt x tolerance)
  (stream-limit (sqrt-stream x) tolerance))

; exercise 3.65
(define ln2-stream
  (partial-sums (ln2-summands 1)))
(define (ln2-summands n)
  (cons-stream (/ 1.0 n)
               (stream-map - (ln2-summands (+ n 1)))))

(define (euler-transform s)
  (let ((s0 (stream-ref s 0))           ; Sn-1
        (s1 (stream-ref s 1))           ; Sn
        (s2 (stream-ref s 2)))          ; Sn+1
    (cons-stream (- s2 (/ (square (- s2 s1))
                          (+ s0 (* -2 s1) s2)))
                 (euler-transform (stream-cdr s)))))

(define (make-tableau transform s)
  (cons-stream s
               (make-tableau transform
                             (transform s))))

(define (accelerated-sequence transform s)
  (stream-map stream-car
              (make-tableau transform s)))

(define (square x) (* x x))

;; check time
;(define (timed-test proc)
;  (start-test proc (current-milliseconds)))
;
;(define (start-test proc start-time)
;  (let ((result (proc)))
;    (if result
;        (report-timed (- (current-milliseconds) start-time) result)
;        (= 0 1))))
;
;(define (report-timed elapsed-time result)
;  (display "time : ")
;  (display elapsed-time)
;  (display ",  result : ")
;  (display result)
;  (newline))

; execute
(define (f)
  (let ((start-time 0))
    (begin
      (display "value : ")
      (set! start-time (current-milliseconds))
      (display (stream-limit (accelerated-sequence euler-transform ln2-stream) 0.001))
      (display "  time : ")
      (display (- (current-milliseconds) start-time))
      (newline)
      (display "value : ")
      (set! start-time (current-milliseconds))
      (display (stream-limit (euler-transform ln2-stream) 0.001))
      (display "  time : ")
      (display (- (current-milliseconds) start-time))
      (newline)
      (display "value : ")
      (set! start-time (current-milliseconds))
      (display (stream-limit ln2-stream 0.001))
      (display "  time : ")
      (display (- (current-milliseconds) start-time))
      (newline))))
(f)

그 허용 오차보다 작은 차이를 보이는 원소를 내놓는 프로시저를 만드는 문제입니다.

프로시저에 대한 설명이 문제에 적혀있어 거기에 맞춰 만들었습니다.

잘 되는군요.^^

참조

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

; 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.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)
  (define (iter i)
    (if (= i n)
        'done
        (begin (display (stream-ref S i))
               (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.63
(define (sqrt-improve guess x)
  (average guess (/ x guess)))

(define (average x y)
  (/ (+ x y) 2))

(define (sqrt-stream x)
  (define guesses
    (cons-stream 1.0
                 (stream-map (lambda (guess)
                               (sqrt-improve guess x))
                             guesses)))
  guesses)

; exercise 3.64
(define (stream-limit stm tolerance)
  (let ((element1 (stream-car stm)) ; 앞의 원소
        (element2 (stream-car (stream-cdr stm)))) ; 뒤의 원소
    (if (< (abs (- element1 element2)) tolerance)
        element2
        (stream-limit (stream-cdr stm) tolerance))))
(define (sqrt x tolerance)
  (stream-limit (sqrt-stream x) tolerance))

; execute
(sqrt 4 0.00001)
(sqrt 9 0.00001)
(sqrt 16 0.00001)
(sqrt 100 0.00001)
(sqrt 2 0.00001)

이는 분모에 오는 수열의 역수를 구한 뒤 이 둘을 곱하면 됩니다.

잘 되는군요.^^

확인하는데 쓰인 수식은 책에 나오듯이 tangent와 1/(1-x)입니다.

특히 1/(1-x)를 만들 때 분자는 sin²x + cos²x을,

분모에는 ones의 덧셈 역원을 더하여 0의 스트림을 구현하였습니다.

그렇게 복잡하게 만들었음에도 잘 나오더군요.^^

MATLAB에서 tangent의 power series를 확인해보니 결과가 동일합니다.^^

참조

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

; 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.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)
  (define (iter i)
    (if (= i n)
        'done
        (begin (display (stream-ref S i))
               (display "  ")
               (if (= (remainder (+ i 1) 10) 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))))

; execute
(define f1 (div-series sine-series cosine-series))
(print-stream-n cosine-series 10)
(print-stream-n sine-series 10)
(print-stream-n f1 10)
(newline) (newline)

(define constant_one
  (add-streams (mul-series sine-series sine-series)
               (mul-series cosine-series cosine-series)))
(define one_minus_x
  (cons-stream 1
               (cons-stream -1
                            (add-streams ones
                                       (scale-stream ones -1)))))
(define f2 (div-series constant_one one_minus_x))
(print-stream-n constant_one 10)
(print-stream-n one_minus_x 10)
(print-stream-n f2 10)

이 문제는 상수항이 1인 power series의 역수를 구하는 프로시저를 만드는 문제입니다.

문제에서 어떻게 만들지 설명하기에 거기에 맞춰 구하면 됩니다.

잘 되는군요.^^

확인한 수식은 e^x의 역수인 e^(-x)와 1/(1-x)의 역수입니다.

MATLAB에서 확인한 결과입니다.

두 결과가 딱 맞는군요.^^

참조

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

; 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.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)
  (define (iter i)
    (if (= i n)
        'done
        (begin (display (stream-ref S i))
               (display "  ")
               (if (= (remainder (+ i 1) 10) 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)

; execute
(define f1 (invert-unit-series exp-series))
(print-stream-n exp-series 6)
(print-stream-n f1 6)
(newline) (newline)

(define f2 ones)
(print-stream-n f2 6)
(define invert_f2 (invert-unit-series f2))
(print-stream-n invert_f2 6)

빈칸을 채워 넣으면 되는 간단한 문제이지만,

어제부터 오늘까지 아무리 생각해도 틀에 맞춰 할 수 없었기에

제가 스트림에 대한 이해가 많이 부족하다는 것을 느꼈습니다.

결국 '이렇게 하면 되지 않을까?'와

'덧셈이 점점 증가하니 mul-series를 부르는 것과

나머지를 처리하는 프로시저를 불러 이를 더하면 되지 않을까?'라는 생각으로

여러 번 프로시저를 돌려 값을 확인하여 답을 구했습니다.

그렇게 답을 구했음에도 왜 저 코드가 맞는지는 이해가 되지 않습니다.OTL....

스트림은 재미있으면서도 새로운 구조라 그런지 제 머리에 인식이 잘 안되네요.ㅜ

제일 처음에 위와 같은 코드를 짰습니다.

쉽게 생각한 것이지요.

그런데 sin²x + cos²x의 값이 1이 나왔기에 맞는 줄 알았습니다.

하지만 이상하다는 생각에 e^x를 두 번 곱한 값을 출력하도록 하였습니다.

위의 결과는 MATLAB을 이용해서 얻었습니다.

즉, e^2x의 값이 틀렸다는 것을 알 수 있었습니다.

그 이후로 이렇게 맞춰보고 저렇게 맞춰보고 연습장에 적어가며 답을 맞춰보았습니다.

그러다 결국 답에 도착하였습니다.

두 개 모두 맞다는 것을 확인할 수 있습니다.

이 문제를 맞추는데 최종적으로 다른 이의 답이 도움이 되었습니다.

'SICP Exercise 3.60.'

이에 감사의 인사를 드립니다.

참조

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

; 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.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)
  (define (iter i)
    (if (= i n)
        'done
        (begin (display (stream-ref S i))
               (display "  ")
               (if (= (remainder (+ i 1) 10) 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)))))
; execute
(define a (add-streams (mul-series sine-series sine-series)
                       (mul-series cosine-series cosine-series)))
(print-stream-n cosine-series 10)
(print-stream-n sine-series 10)
(newline)
(print-stream-n a 10)
(newline) (newline)

(define b (mul-series exp-series exp-series))
(print-stream-n exp-series 6)
(newline)
(print-stream-n b 6)

power series를 스트림으로 구현하는데,

특히 b번이 아주 흥미로운 결과를 보여주었습니다.

a. 수열을 적분하는 프로시저를 만드는 문제입니다.

간단히 integer 스트림과 계수 스트림을 나누는 것으로 해결하였습니다.

b. cosine과 sine 함수를 정의하는 문제입니다.

예제로 나온 exponential 함수의 정의는 자기 자신을 적분하는 것으로 나와있습니다.

왜냐하면 exponential 함수는 미분을 하나 적분을 하나 자기 자신이기 때문입니다.

(물론 부정적분을 하면 상수가 나오겠죠.)

이에 맞춰 cosine과 sine 함수 정의에 각각을 적분하는 것으로 끼워넣었습니다.

처음에는 잘 되겠는가 싶었으나 의외로 깔끔하게 답이 나왔습니다.

서로가 서로를 정의하는데 쓰이고 있음에도 이렇게 잘 나오다니... 놀랐습니다.^^

스트림을 사용하면 이런 것도 가능하군요.^^

참조

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

; 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.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)))))))))

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

; a
(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)))

; execute
(define a (scale-stream integers 10))
(define b (integrate-series a))
(print-stream-n a 10)
(print-stream-n b 10)
(newline)

; b
(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)))

; execute
(print-stream-n exp-series 10)
(print-stream-n cosine-series 10)
(print-stream-n sine-series 10)

해당 프로시저를 처음 봤을 때 무슨 프로시저인가 고민했습니다.

왜 num에 radix를 곱하는지, 다음으로 넘길 때 왜 remainder를 써서 나머지를 넘기는지

그 이유를 알 수 없었습니다.

그래서 책에 나오는 예제인 (expand 1 7 10)을 따라 해보았습니다.

1 4 2 8 5 7 1 4 2 8 5 7 1....

해당 연산을 하면서 어디서 많이 해보던 느낌이 많이 들었습니다.

몫을 기록하고 나머지에 10을 곱해 다시 몫을 기록하는 행위...

다음 예제인 (expand 3 8 10)을 따라 해보았습니다.

3 7 5 0 0 0 0 0 0 0...

여기까지 해보고나서 무엇인지 알게 되었습니다.

분수를 소수로 바꾸는 연산!

처음 예제는 1/7을 소수 0.1428571428571...로 표현한 것이고,

두 번재 예제는 3/8을 소수 0.375로 표현한 것입니다.

이런 방법은 나눗셈 표기법으로 구하는 것과 동일합니다.

출처 : 3. 소수의 나눗셈

즉, 몫을 위에 적고 남은 나머지에 10을 곱해 다시 몫을 구하는 것과 동일합니다.

어렸을때부터 언제나 하였던 것임에도 이렇게 보니 신기하네요.

그만큼 창의성이 없다는 뜻인지도...OTL.....

참조

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

; 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.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)))))))))

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

(define (expands num den radix)
  (cons-stream
   (quotient (* num radix) den)
   (expands (remainder (* num radix) den) den radix)))

; execute
(define a (expands 1 7 10))
(define b (expands 3 8 10))
(print-stream-n a 10)
(newline) (newline)
(print-stream-n b 10)

위와 같은 방법으로 피보나치 수를 구합니다.

따라서 n번재 피보나치 수열을 구하려면 n-1번의 덧셈이 필요합니다.

살펴보니 10번째 값을 구할 때 add_execute가 9번 나왔습니다.

즉, 제 예상이 맞는 듯싶습니다.^^

재미있는 것은 10번째 값을 구할 때 0부터 9까지 모두 구합니다.

따라서 그 다음으로 20번째 값을 구할 때 10번만 덧셈합니다.

즉, 11번부터 20까지 덧셈을 행하는 것입니다.

그럼 이렇게 값을 저장하는 것이 아닌 방법이라면 어떻게 되는지 생각해보았습니다.

피보나치 수는 위와 같은 나무꼴(tree)를 그립니다.

이는 Full binary tree와 비슷합니다.

그리고 fibs(n)은 n-1 height를 가집니다.

따라서 2^(n-1)개의 terminal vertex를 가지고, 총 vertex의 개수는 (2^n) - 1입니다.

그렇기에 덧셈의 수가 지수 비례로 늘어납니다.

여전히 코드를 보고 수행 시간을 판단하는 것은 어렵습니다.

2학기 때 자료구조를 듣는데 걱정되네요.ㅜㅜ

참조

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

; 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)
  ; print count add call
  (define (add a b)
    (display 'add_execute)
    (newline)
    (+ a b))
  (stream-map add 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.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)))))))))

; answer
(define fibs
  (cons-stream 0
               (cons-stream 1
                            (add-streams (stream-cdr fibs)
                                         fibs))))

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

;(print-stream-n fibs 10)
(display (stream-ref fibs 10))
(newline) (newline)
(display (stream-ref fibs 20))

그리고 거기에 대해 상담을 받고 자료를 받았지만, 잘 기억이 나지 않네요.^^;;;

그러다 Unique님의 'MBTI'에서 MBTI에 관한 방송 자료를 얻을 수 있었습니다.

과학자 INTJ

이 방송은 아이의 성격유형에 따라 어떻게 지도해야하는지 조언하는 프로그램입니다.

여기서 해당 유형에 대해 여러 얘기를 하는데 재미있는 이야기 하나 들었습니다.

예전에 저희 연구소의 어떤 애가 세미나를 하려고

학교에서 다른 곳으로 무거운 가방을 들고 가고 있었어요.

그런데 뒤에 오던 애들은 짐이 너무 많으니까 차에 짐을 실어서 가다보니까

그 친구가 먼저 무거운 가방을 들고 가는 것을 보았어요.

그 모습을 보고 "빨리 타라. 이거 타고 같이 가자."라고 했더니

괜찮다면서 안 타고 갔습니다.

자꾸 타라고 해도 너무나 안 타겠다고 하자 오히려 타라고 한 사람이 민망해져

자기들끼리 먼저 가면서 '왜 안타죠? 이상해요.'라고 얘기했습니다.

물론 타면 좋을텐데 그 순간에 자기가 몰두하고 있거나 어떤 생각에 빠져있으면

육체적으로 힘든 것은 그리 중요한 것이 아니에요.

그래서 그냥 가는거에요.

하지만 사실은 배려를 해준 쪽을 생각한다면

'나 때문에 이렇게 쫓아와서 태워주려는구나. 내가 타야겠다.'라는 생각을 하지 못합니다.

왜 나를 태워야 하는 것인지에 대해서 감각이 조금 무디다고 볼 수 있습니다.

- 해당 방송 14분에서 15분 사이

해당 얘기를 들으니까 뜨끔해지더군요.

제가 도서관에서 근무할 때 이런 일이 많았습니다.

도서관은 산 위에 있고 집은 밑에 있기에

같이 퇴근하는 공무원들이 산 밑까지 차를 태워주는 경우가 많았습니다.

어차피 산길은 같이 내려가니 괜찮다면서 저에게 타라고 하더군요.

하지만 피곤한 날이나 급한 일이 아니고서는 대부분 거절했습니다.

이유는 하나.

퇴근 후 집으로 걸어가는 30분 가량의 시간 동안

그 날에 했던 일과 앞으로 남은 6시간 동안 해야할 일을 정리하고,

산에서 내려오며 바라보는 하늘과 경치를 바라보면서 스트레스를 풀 수 있었습니다.

지금 저 이야기를 들으니 그 때 배려를 한 사람들에게 무례를 하였네요.OTL...

그걸 그 때에는 알지 못하고 이렇게 이야기를 들어서 알게 되다니....ㅜ

INTJ의 주기능 부기능 열등기능이라는 코너가 있습니다.

주기능은 N(직관형)으로

현재의 행동이 미래에 미칠 영향을 잘 파악한다고 합니다.

저는 그리 미래 예측을 못합니다만...OTL....

부기능은 T(사고형)으로

의사결정을 할 때 객관적이고 논리적이라고 합니다.

논리가 언제나 모자라 고생하고 있습니다만....?OTL....

열등기능은 S(감각형)으로

가까운 사람에게 무관심하게 행동한다고 합니다.

최근 여기에 대해 느낍니다.

가까운 사람에게 무관심하다...

그래서 친구들이 멀어지는 듯싶습니다.^^ㅜ

관련 항목으로 INTJ에 대한 얘기가 있네요.

'INTJ_' 

일반적 특성:

- 아주 이론적이다

-> 아닌 듯...ㅜ

- 어려운 난관은 자극제가 되며, 창의성을 요하는 도전에 응하는 것을 즐긴다.

-> 최근 SICP를 풀면서 느낍니다.

조금 어렵기는 하지만 새로운 내용을 계속해서 배우고 있어 상당히 재미있습니다.

- 비효율적으로 시간을 끄는 것을 싫어한다.

-> 예전에 약속 시간을 지나 기다리는 것을 비효율적이라 생각해서

친구와 싸웠던 기억이 있네요.ㅜ

- 놀기 위해서 노는 기술을 배운다.

-> 이건 아닌 듯싶네요.

스타크래프트를 즐기면서 해당 기술을 배우지는 않았습니다.

그냥 즐기면 되는 것이니까요.^^

- 겉은 강하지만 속은 아주 여리다

-> 외강내유...이네요.^^ㅜ

- 인간관계에서 인간적인 면이 부족해서 능력을 인정받지 못하는 경우가 있다.

-> 이건 모르겠네요.

만약 YES라면 인간적인 면도 능력이 될 수 있기 때문이고,

NO라면 능력이 모자람을 인간적이 면이 부족하다는 핑계를 대는 것이 아닌가 싶습니다.

- 통찰력과 분석력이 뛰어나며 고집이 대단하다.

-> 세 번째는 공감...;;

- 재능은 많으나 이로 인해 적응이 어려울 수 있다

-> 재능?(풋...ㅜㅜ)

- 학구열이 강하다 (특히 순수학문)

-> 학구열이 강한지도 의문...

- 대인관계에서 차갑다는 인상을 줄 수 있다.

-> 그런 얘기는 몇 번...ㅜ

- 하고자 하는 의지가 강하다.

-> 역시 잘...

- 잡담을 시간 낭비라고 생각한다.

-> 우와... 이정도로 생각하는 사람을 보면서 '무서운 사람인걸?'이라 생각했는데,

그것이 INTJ 유형의 일반적 특성입니까?

같은 유형에 있어도 역시 무서운 사람은 무섭습니다.(응?)

- 일하는 곳에서 사람을 쉽게 사귄다.

-> 일하는 곳이 많지는 않았지만...

일하는 곳이라면 어차피 거의 매일 봐야하는 사람들 아닙니까?

그럼 인사하고 여러 얘기를 나누다보면 자연스럽게 친해지지 않나요???

- 노는 자리를 어색해 한다.

-> 정말 어색... 뻘쭘... 이런 표정입니다.

출처 : 이명박 당선인, 신년하례법회 참석

날 좀 꺼내줘...

- 주어진 일에 성실하며 노력하는 편이다.

-> 이것도 잘...

- 자신에게 의미가 있는 일에 열성적이다.

-> 의미가 있는 일에는 당연히 열성적이지 않나요??

그 의미가 있는 일을 찾는 것이 어렵다고들 하더군요.OTL...

- 회식을 별로 좋아하지 않는다.

-> 네.. 좋아하지 않습니다.

성격 이유도 있지만, 건강상 술을 금기하는터라 회식자리는 힘듭니다.

그래서 사회생활 특히 직장생활을 제대로 할 수 있을지 모르겠습니다.ㅜ

- 앞에 나서는 것을 대단히 싫어한다.

-> 이것이 성격 때문인지 잘 모르겠습니다만,

초등학교 6년, 중고등학교 6년. 총 12년 동안 반장이 한 번도 되지 않았습니다.

언제나 후보로 올라왔지만 반장이 안되더군요.

아마도 사람들을 설득시키는 능력이 없나봅니다.^^

그 덕분에 앞에 나서서 무언가를 하는 일을 어려워합니다.

- 혼자서 공상하는 것을 즐긴다.

-> 혼자만의 세계에 빠지죠.

가끔 자폐증이 아닌가 고민하고 있습니다.OTL....

- 사적인 얘기는 거의 하지 않는다.

-> 이것은 아닌 듯...

제 블로그를 보면 사적인 얘기 투성...^^;;

- 영화를 볼 때 뭔가 잘못된 장면이 없는지 찾으면서 보는 경우가 있다.

-> 대부분입니다만...

이상하게도 동영상의 경우 그런 경우가 매우 많습니다.

- 자신이 학생이라고 해도 옳다면 교수하고도 싸울 수 있다.

-> 사실 이것때문에 이런 뻘짓(?)을 했습니다.

싸운다는 것이 조금 이상하지만,

제가 맞다고 생각하는 것에 대해 여러 얘기를 하였습니다.

하지만 그 때마다 느끼는 것은

'교수라는 직업은 아무나 되는 것이 아니구나.'입니다.

과연 얼마나 공부를 해야 그 정도 경지에 이르는지....OTL....

(전략)

이런 생각은 14세기 프랑스 철학자 장 뷔리당(Jean Buridan)이 주석을 단,

아리스토텔레스의 천체론(De caelo)에서 처음 나왔다.

그 책에서 뷔리당은 똑같이 맛 좋은 소스를 뿌려 놓은 음식 두 가지를

완벽한 이성을 갖춘 개 앞에 놓아두면,

개는 무엇부터 먹어야 할지 정하지 못하여 끝내 굶어 죽게 된다고 주장하였다.

(역주 : 이것은 흔히 뷔리당의 당나귀로 알려진 내용이다.)

The fundamental phenomenon here was originally observed

by the fourteenth-century French philosopher Jean Buridan

in his commentary on Aristotle's De caelo.

Buridan argued that a perfectly rational dog placed

between two equally attractive sources of food will starve to death,

because it is incapable of deciding which to go to first.

두 개의 먹이를 앞에 두고 어느 것을 먼저 먹을 것인가 고민하다가 굶어 죽는다라...

먼저 뷔리당의 당나귀라는 것을 검색해보았습니다.

뷔리당의 당나귀(Buridan's ass)

양쪽에 동질(同質) ·동량(同量)의 먹이를 놓아두었을 때

당나귀가 어느 쪽 먹이를 먹을 것인가를 결정하지 못하여 아사(餓死)한다는 이야기.

프랑스의 스콜라 철학자 J.뷔리당이 하였다고 전해지는 유명한 말이다.

이 말 자체는 아리스토텔레스의 《천체론(天體論)》에서 개를 예로 들어 인용되었으며

J.뷔리당은 이 책에 주해(註解)를 남겼다.

그의 저서에는 이 말이 들어 있지 않으나,

뷔리당의 자유의지론(自由意志論)을 야유하여 다른 사람들이 말한 것으로 추측된다.

이 말은 두 동등한 힘의 모티프 사이에서

의지(意志)의 행사(行使)를 할 수 없다는 것을 증명하는 데 사용된 말이다.

- 두산백과사전

천체론에서는 개가 쓰이는데 당나귀로 바뀌었군요.^^;;

여하튼 두 동등한 힘의 모티브 사이에서 의지의 행사를 할 수 없다라...

SICP에서 말한 동등한 중요도를 가지는 프로세스가

서로 CPU의 자원을 가지려고 할 때 deadlock이 나온다는 얘기와 통한다고 생각합니다.

그렇다면 과연 이산적인 컴퓨터 세상이 아닌 현실 세계에서는 어떠할까요?

이와 관련된 이야기가 있나 싶어 살펴보았습니다.

그러자 재미있는 글이 몇 개 보였습니다.

그 중 두 개를 소개하겠습니다.

뷔리당은 정말이지 너무 배가 고팠다.

그의 허기는 무슨 일에든 완벽하게 합리적인 결정만 내리겠다는

그의 결심과 더불어 시작되었다.

문제는 냉장고의 음식이 다 떨어졌는데 그가 살고 있는 곳에서

정확히 똑같은 거리에 두 개의 똑같은 이마트 지점이 있다는 것이다.

이렇게 되면 그로서는 둘 중 한 가게를 선택하고,

다른 한쪽에 가지 않을 충분한 이유가 없다.

그래서 어느 한 이마트를 선택할 합리적 근거를 찾아내지 못한 채

끊임없이 망설이는 상태에 갇혀 있었던 것이다.

배에서 꾸르륵 소리가 나는 것을 더는 참을 수 없을 때

그는 한 가지 해결책을 찾아냈다고 생각했다.

굶어죽는 것이 분명 비합리적인 일이라면,

두 군데의 이마트 중 임의로 한 군데를 선택하는 것이 합리적이지 않을까?

단순히 동전을 던지거나 자기 마음에 드는 쪽으로 방향을 잡기만 하면 될 것이다.

이것은 집에서 아무것도 안하고 가만히 앉아 있는 것보다는

분명히 더 합리적인 일이었다.

그러나 그렇게 되면 완벽하게 합리적인 결정만 내리겠다는

그 규칙을 무너뜨려야 하지 않을까?

이런 그의 생각은,

이를테면 동전 던지기와 같은 비합리적인 결정을 내리는 것이

합리적인 일임을 내포하고 있다.

그러나 ‘합리적인 비합리성’이란 것이 과연 합리적일까?

뷔리당은 치솟는 혈당 때문에 그 질문에 답할 수 없었다.  - 뷔리당의 역설 -

- 합리적 판단의 비합리성 그 오류와 한계

'뷔리당의 당나귀'라는 이야기가 있습니다.

뷔리당은 14세기의 프랑스 철학자입니다.

이 이야기는 그의 책 어디에서도 출처를 찾을 수 없지만

예로부터 '뷔리당의 당나귀'라는 이름으로 유명한 예화입니다.

쫄쫄 굶어서 뱃가죽이 등에 달라붙을 정도로 배고픈 당나귀 한 마리가 있었습니다.

다행스럽게도 건초로 뒤덮인 산을 발견했습니다.

하지만 불행하게도 당나귀는 두 개의 산을 동시에 보고 말았습니다.

건초들은 양쪽이 똑같았습니다.

그래서 당나귀는 헷갈리기 시작했던 것입니다.

어느 산의 건초를 먼저 먹어야 할까?

어리석기 짝이 없는 헷갈림이지만 당나귀는 완전히 혼란스러워졌습니다.

오른쪽 산부터 먹어야겠다고 마음먹고

오른쪽 산을 향해 두세 걸음 걸어가다보면 왠지 왼쪽 산이 더 맛있게 보입니다.

그래서 왼쪽으로 방향을 틀고 가다보면

이번에는 오른쪽의 것이 더 맛있게 보이는 것입니다.

결국 다음날 아침,

당나귀는 건초로 뒤덮인 두 개의 산 중간에서 굶어 죽은 채 발견되었습니다.

이것이 '뷔리당의 당나귀'라는 이야기입니다.

정말 어리석지 않습니까?

앞서 저는 '어리석기 짝이 없는 헷갈림'이라고 말씀드렸습니다.

하지만 정말 당나귀가 바보였을까요?

그렇다면 이처럼 헷갈리고 미혹되어 살아가고 있는 인간은 어떨까요?

저는 전에 한 국립대학에서 철학을 가르쳤는데,

인생 상담을 하러 학생들이 이따금 찾아오곤 했습니다.

가장 많은 상담을 그 대학을 그만두고

다른 대학으로 편입하는 것이 나은가 하는 것이었습니다.

그래서 저는 물었습니다.

"자네는 정말 이 대학을 그냥 계속 다녀도 좋고

다른 대학으로 옮겨가도 좋다고 생각하고 있는가?"

그러면 학생은 "그렇습니다."라고 대답합니다.

몇차례 확인해보지만 학생들의 대답에는 변함이 없습니다.

"그런 이 주사위를 던져보게.

짝수가 나오면 이 학교에 남고, 홀수가 나오면 편입하기로 결정보세."

그러면 대부분의 학생들은 화를 냅니다.

"저는 정말 심각하게 고민하고 있습니다. 선생님, 장난치지 마십시오."

저는 장난치고 있던 것이 아니었습니다.

어느 쪽을 택해도 똑같은 것이라면

일찌감치 어느 쪽이든 결정해서 자신이 정한 길을 열심히 걸어가는 편이 더 낫다,

어는 쪽이라도 괜찮은데 괜히 미적미적 방황하고 있다면

그 방황은 헛된 것이라고 생각했던 것입니다.

그러므로 주사위를 던져서라도 결단을 내리도록 권했던 것입니다.

어느 쪽도 괜찮다면 우연에 의해서라도 결정짓는 것이 현명하다고 저는 생각합니다.

그런데 학생의 입장에서는

인생의 여러 가지 문제들에 '정답'이 있다고 생각하시는 것 같습니다.

이것일까 저것일까 고민하며 방황할 때 인생의 지혜를 가진 사람이라면

딱 맞는 충고를 해줄 수 있을 거라고 생각하는 성향이 매우 짙습니다.

교수나 전문가에게 상담하는 것도 그런 충고를 구하기 위해서일 것입니다.

그렇지만 인생에 '정답'이 있을까요?

이것이냐, 저것이냐 두갈래 길을 걸어가보고 어느 쪽이 옳았는지 비교할 수는 없습니다.

인생의 길은 자신이 지금 걸어가고 있는 길을 묵묵히 가는 것 외에 다른 도리가 없습니다.

<반야심경>에서는 "무지역무득無智亦無得"이라고 말하고 있습니다.

'득得'은 깨달음을 얻는 것을 말합니다.

지혜가 없으면 깨달음도 없다는 뜻입니다.

소승불교는 지혜나 깨달음에 집착하고 있지만

그렇게 되면 마치 인생에 '정답'이 있는 것처럼 착각해버리게 됩니다.

그러므로 <반야심경>은 지혜나 깨달음에 집착할 필요가 없다고 가르치고 있습니다.

- [에세이] 제51강 뷔리당의 당나귀

두 글 모두 재미있는 글입니다.^^

사실 두 번째 글에서 받아들이기 힘든 부분도 있지만,

뷔리당의 당나귀라는 것과 그 비합리성에 대해 이해할 수 있는 좋은 글이라 생각합니다.

그러고보니 사랑 얘기에도 비슷하지 않을까요?

누구와 사랑하고 결혼한다는 것.

그것은 다른 쪽으로 넘어갈 수 없는 그야말로 하나의 선택이 되겠지요.

(이혼과 재혼이 있지 않느냐라고 말씀하신다면... '평생'이라는 제한을 두겠습니다.

내세가 있지 않느냐라고 말씀하신다면... 없다고 하겠습니다.;;;)

그렇게 생각을 하니 사람 사는 세상은

컴퓨터 세상처럼 중요도가 100% 맞는 일은 발생하지 않겠지만,

그 모호성 때문에 100%로 맞아 보이는 일은 분명 있을 것입니다.

그럴 때 뷔리당의 당나귀가 되어 고민에만 빠져 굶어 죽을 것인지,

주사위를 던져서라도 선택을 해야할 것인지...

생각해보니 상당히 어려운 문제네요.^^

다만, 이것 하나만은 기억해야할 듯싶습니다.

도저히 선택을 할 수 없어 주사위를 던지든 동전을 던지든간에

그 이후에 나타나는 일에 대한 책임을 주사위나 동전에 미루지 말자는겁니다.

최근 기사에서 그런 사람이 상당히 역겹다는 것을 느끼기에

그런 역겨운 사람은 되지 말아야겠다는 가이드라인을 잡고 싶습니다.

그러고보니 경험이 많다는 점, 생각이 많다는 점은

이러한 가이드 라인이 많아 중요도를 저울질 할 때

세밀한 부분까지 살펴볼 수 있는 능력이 있다는 것이 아닐까 싶네요.^^

(능력이 있는 것이지 그렇게 한다는 것은 아닙니다.)

PS

이번에도 결론이 다른 길로 빠지고 말았습니다.OTL....

하지만 나름 재미있는 생각으로 마인드 맵을 그려보지 않았나 싶습니다.^^

뷔리당의 당나귀에 대해 아시는 분은 댓글 부탁드립니다.^^