#lang racket
(define (car-flot f) ;;TODO: USE OR REMOVE
(car f))
(define (cdr-flot f)
(force (cdr f)))
(define flot-null null)
(define (flot-null? f)
(null? f))
(define-syntax consflot
(syntax-rules ()
((consflot a b) (cons a (delay b)))))



(define (gen-signal a b dt c)
  (gen-signal_inter a b dt c 0)
  )

(define (gen-signal_inter a b dt c step)
 (letrec (
    [signal (lambda(x) (* a (sin (+ c (* b (* x dt))))))]
    [flot (consflot (signal step) (gen-signal_inter a b dt c (+ step 1)))]
    ) flot))



(define (flot->liste n flot)
  (flot->liste_inter 0 n flot)
  )

(define (flot->liste_inter i n flot)
  (
   if (= i n) '()
       (cons (car-flot flot) (flot->liste_inter (+ i 1) n (cdr-flot flot)))

  ))


(define (quantification flot ampl nbits)
  ( ;must return cons car + promise
   letrec(
          [signalvalue (car-flot flot)]
          [classnumber (expt 2 nbits)]
          [currentvalue (- (exact-floor ( * ( + ampl signalvalue) (/ classnumber 2))) (/ classnumber 2))]
          [res (consflot (/ currentvalue (/ classnumber 2)) (quantification (cdr-flot flot) ampl nbits))]
   ) res
  )
 )

;(- (floor (* (+ amplitude value) (/ quantification 2))) (/ quantification 2)) --> amounts of eights

(define flot1 (gen-signal 1 1 0.5 0))
(define flot2 (quantification (gen-signal 1 1 0.5 0) 1 4))
(flot->liste 10 (quantification (gen-signal 1 1 0.5 0) 1 4))