; 10.11.scm
; 2024-10-12
; $Id: 10.11.scm 1.1 2024/11/03 06:54:05 s Exp $
;
; a : amount
; d : discount factor, d[k] = d(0,k)
; f : forward rate, f[k] = f(k-1,k) 
; g(r) : pv2 - pv1
; pv1 : present value in variable rate
; pv2 : present value in fixed rate
; r : fixed rate
; s : spot rate, s[k] = s(k)
; x : cash flow in variable rate, x[0] = x(k)
; y : cash flow in fixed rate, y = a * r

(use gauche.array)
(use gauche.sequence)

; procedure
(define g (lambda (a r pv1) ; g=pv2-pv1
        (define df1  (/ (expt (+ 1 r) 1)))
        (define df2  (/ (expt (+ 1 r) 2)))
        (define df3  (/ (expt (+ 1 r) 3)))
        (define df4  (/ (expt (+ 1 r) 4)))
        (define df5  (/ (expt (+ 1 r) 5)))
        (define df6  (/ (expt (+ 1 r) 6)))
        (define y   (* a r))
        (define pv2 (* y (+ df1 df2 df3 df4 df5 df6)))
        (- pv2 pv1)
    )
)
(define sum (lambda (x) (fold + 0 x)))

; input
(define a 1000)
(define s (vector 0.00 0.070 0.073 0.077 0.081 0.084 0.088))

; calculation
(define n (vector-length s))
(define f (vector 0.0 0.0 0.0 0.0 0.0 0.0 0.0))
(for-each 
    (lambda (x)
         (cond [(= x 0)
                (set! (ref f x) 0)]
               [(= x 1)
                (set! (ref f x) (ref s 1))]
               [else
; f[i] = (1 + s[i]) ** i / (1 + s[i - 1]) ** (i - 1) - 1;
                (set! (ref f x)
                      (- (/ (expt (+ 1 (ref s x)) x)
                            (expt (+ 1 (ref s (- x 1))) (- x 1))) 1)
                )]
         )
    )
    (iota n)
)
(define x   (map (lambda (x) (* a x)) f))
(define d   (map-with-index (lambda (i _)
                (/ 1 (expt (+ 1 (ref s i)) i))) s))
(define pv1 (sum (map (lambda (x1 x2) (* x1 x2)) x d)))

; solve g(a r pv1) = 0
(define r (iota 200 0.08700 0.00001))
(define index_r
    (do ((i 0 (+ i 1)))         ; i : loop counter
        ((> (g a (ref r i) pv1) 0) i) ; break condition, return value is i.
    )
)
(define root (ref r index_r))

; output
(print '10.11.scm)
(print "a " a)
(print "s " s)
(print "f " (map (lambda (x) (/ (round (* x 1000)) 1000)) f))
(print "x " (map (lambda (x) (/ (round (* x  100))  100)) x))
(print "d " (map (lambda (x) (/ (round (* x 1000)) 1000)) d))
(print "pv1 in variable rates " (/ (round (* pv1 1000)) 1000))
(print "(r, g(r)) = (" (/ (round (* root    1e5)) 1e5) ", "
                       (/ (round (* (g a root pv1) 1e5)) 1e5) ")")
; end