#lang racket

(require "stream-base.rkt")

; pi approximations with Euler series acceleration

; apply an operation (op v e) to each element e of the stream
(define (op-on-stream op v s)
  (s-map (lambda (e) (op v e)) s) )

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

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

(define (partial-sums s)
  (if (s-null? s) s-empty
      (s-cons (s-first s) 
                   (op-on-stream + (s-first s) (partial-sums (s-rest s))))
      )
  )

(define (pi-summands n)
  (s-cons (/ 1.0 n)
               (s-map - (pi-summands (+ n 2)))))

(define pi-stream
  (scale-stream (partial-sums (pi-summands 1)) 4))

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

(define faster-pi-stream (euler-transform pi-stream))

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

(define (accelerated-sequence transform s)
  (s-map s-first
              (make-tableau transform s)))

(define fastest-pi-stream (accelerated-sequence euler-transform pi-stream))