(define (triangular)
  (let ((first-random (random 1.0))
        (second-random (random 1.0)))
    (/ (+ first-random second-random) 2)))

(define (triangular-mean mean)
  (* (triangular) mean 2))

(define (make-section duration density start-time)
  (if (<= density 0)
    nil
    (let* ((onset-time (* (random 1.0) duration))
           (global-onset (+ start-time onset-time))
           (sustain (* (triangular)
                       (- duration onset-time))))
      (cons (new midi
              :keynum (+ 21 (triangular-mean 39))
              :time global-onset
              :duration sustain
              :amplitude (triangular))
            (make-section duration (- density 1) start-time)))))

(define (make-piece number-sections mean-duration mean-density start-time)
  (if (<= number-sections 0)
    nil
    (let* ((duration (triangular-mean mean-duration))
           (density (triangular-mean mean-density))
           (next-start (+ start-time duration)))
      (append (make-section duration density start-time)
              (make-piece (- number-sections 1) 
                          mean-duration mean-density next-start)))))

(define (make-profiled-section duration density start-time
                               mean-pitch mean-amplitude mean-duration pitch-scale)
  (if (<= density 0)
    nil
    (let* ((onset-time (* (random 1.0) duration))
           (global-onset (+ start-time onset-time))
           (sustain (* (triangular-mean mean-duration)
                       (- duration onset-time))))
      (cons (new midi
              :keynum (+ pitch-scale (triangular-mean mean-pitch))
              :time global-onset
              :duration sustain
              :amplitude (triangular-mean mean-amplitude))
            (make-profiled-section duration (- density 1) start-time
                                   mean-pitch mean-amplitude mean-duration 
                                   pitch-scale)))))

(define (make-profiled-piece number-sections mean-duration mean-density start-time)
  (if (<= number-sections 0)
    nil
    (let* ((duration (triangular-mean mean-duration))
           (density (triangular-mean mean-density))
           (next-start (+ start-time duration)))
      (append (make-profiled-section duration density start-time
                                     (* 44 (random 1.0))
                                     (random 0.5)
                                     (random 0.5)
                                     (+ 21 (random 40)))
              (make-profiled-piece (- number-sections 1) mean-duration mean-density
                                   next-start)))))

(define (make-overlap-piece number-sections mean-duration mean-density start-time)
  (if (<= number-sections 0)
    nil
    (let* ((duration (triangular-mean mean-duration))
           (density (triangular-mean mean-density))
           (next-start (+ start-time (* duration (+ 0.5 (random 0.5)))))) 
      (append (make-profiled-section duration density start-time
                                     (* 44 (random 1.0))
                                     (random 0.5)
                                     (random 0.5)
                                     (+ 21 (random 40)))
              (make-overlap-piece (- number-sections 1) mean-duration mean-density
                                   next-start)))))

(define (random-walk current-location scale)
  (+ (- (* 2 (random scale)) 
        1)
     current-location))

(define (walk-list start-location scale number-of-walks)
  (if (<= number-of-walks 0)
    nil
    (let ((new-value (random-walk start-location scale)))
      (cons new-value (walk-list new-value scale (- number-of-walks 1))))))

(define (make-melody walk-list start-time)
  (if (null? walk-list)
    nil
    (cons (new midi
            :keynum (car walk-list)
            :time start-time
            :duration 0.5
            :amplitude 0.9)
          (make-melody (cdr walk-list) (+ start-time 0.5)))))

(define (directional-melody walk-list start-time)
  (if (null? walk-list)
    nil
    (cons (new midi
            :keynum (+ (car walk-list) 
                       (* start-time 4))
            :time start-time
            :duration (/ 1 (+ 0.5 start-time))
            :amplitude (* start-time 0.1))
          (directional-melody (cdr walk-list) (+ 0.5 start-time)))))