Implementation of Black Scholes option pricing model using Scheme

bs.scm

(define black-scholes
  [letrec (
    [normal (lambda (zz)
        (if (= zz 0) 0.5
          [let ((p 0.2316419) (b1 0.31938153) (b2 -0.356563782) (b3 1.781477937) 
                (b4 -1.821255978) (b5 1.330274428) 
                (f (/ 1 (sqrt (* 2 3.1415926))))
                (abszz (abs zz)))
            [let ((ff (* f (exp (/ (- (expt abszz 2)) 2))))
                  (s1 (/ b1 (+ 1 (* p abszz)))) 
                  (s2 (/ b2 (expt (+ 1 (* p abszz)) 2))) 
                  (s3 (/ b3 (expt (+ 1 (* p abszz)) 3))) 
                  (s4 (/ b4 (expt (+ 1 (* p abszz)) 4))) 
                  (s5 (/ b5 (expt (+ 1 (* p abszz)) 5))))
               [let ((sz (* ff (+ s1 s2 s3 s4 s5))))
                  [if (< zz 0) sz (- 1 sz)]]]]))]
    [days-in-year 365]
    [sqrt-t (lambda (days)
        (sqrt (/ days days-in-year)))]
    [N (lambda (strike s sd r days)
       (let [(ls (log s)) (lx (log strike)) (t (/ days days-in-year)) (sd2 (expt sd 2))]
            (+ (- ls lx) (* r t) (* sd2 (/ t 2)))))]
    [delta (lambda (strike s sd r days)
        (let [(n (N strike s sd r days)) (sqT (sqrt-t days))]
          (let [(d (* sd sqT))]
            (let [(d1 (/ n d))]
            (normal d1)))))]
    [delta2 (lambda (n sd days)
        (let [(sqT (sqrt-t days))]
          (let [(d (* sd sqT))]
            (let [(d1 (/ n d))]
              (normal d1)))))]
    [ND2 (lambda (n sd days)
        (let [(sqT (sqrt-t days))]
          (let [(d (* sd sqT))]
            (let [(d1 (/ n d))]
              (let [(d2 (- d1 (* sd sqT)))]
                (normal d2))))))]
    [bond (lambda (strike s sd r days)
        (let [(n (N strike s sd r days)) (t (/ days days-in-year))]
          (let [(nd1 (delta2 n sd days)) (nd2 (ND2 n sd days))]
            (* (* (exp (* (- r) t)) nd2) (- strike)))))]
    [callValue (lambda (strike s sd r days)
        (let [(n (N strike s sd r days)) (t (/ days days-in-year))]
          (let [(nd1 (delta2 n sd days)) (nd2 (ND2 n sd days)) (b (bond strike s sd r days))]
            (+ (* s nd1) b))))]
    [putValue (lambda (strike s sd r days)
        (let [(t (/ days days-in-year)) (call (callValue strike s sd r days))]
          (+ (- (* (exp (* (- r) t)) strike) s) call)))])
  (lambda (strike s sd r days)
    (list (putValue strike s sd r days) (callValue strike s sd r days) 
          (delta strike s sd r days) (bond strike s sd r days)))])

(define black-scholes-list (lambda (x) (apply black-scholes x)))