Scheme
Scheme - TD n° 11
16 mai 2001
Formes map et lambda
Méthode de Newton (récursions terminales)
Évaluation du tp noté
(define w (make-object frame% "")) (send w show #t) (define (action o e) (send (if (equal? o t1) t2 t1) set-value (send o get-value))) (define t1 (make-object text-field% "Texte1" w action)) (define t2 (make-object text-field% "Texte2" w action))Rajouter un bouton dans l'interface qui vide les fenêtres de texte quand on clique.
(define (vider o e) (send t1 set-value "") (send t2 set-value "")) (make-object button% "Bouton" w vider)Evaluer les expressions suivantes :
> ((lambda (x) (+ x 1)) 3) 4 > ((lambda (x y) (list x y y x)) 3 4) (3 4 4 3) > (map (lambda (x) (+ x 1)) '(3 4 5)) (4 5 6) > (map (lambda (x) (list x (* 2 x))) '(3 4 5)) ((3 6) (4 8) (5 10)) > ((lambda (f) (f 2)) (lambda (x) (+ x 1))) 3 > ((lambda (f) (f 2)) sqrt) 1.4142135623731 > (map sqrt ((lambda (x y z) (list z x y)) 4 9 16)) (4 2 3) > (map (lambda (f) (f 2)) (list sqrt log log sqrt)) (1.4142135623731 0.69314718055995 0.69314718055995 1.4142135623731)La méthode de Newton consiste à calculer:
yn = 1 ( yn-1 + x )
2 yn-1
avec un premier terme quelconque y0. Faire (newton n x y0) en version terminale.
(define (newton n x y0)
(cond ((= n 0) y0)
(else (newton (- n 1) x (/ (+ y0 (/ x y0)) 2)))))
On veut calculer le premier terme tel que yn2 - x en valeur absolue < eps. Modifier la fonction en conséquence.
(define (newton x y0 eps)
(cond ((< (abs (- (* y0 y0) x)) eps) y0)
(else (newton x (/ (+ y0 (/ x y0)) 2) eps))))
On veut calculer le premier terme tel que yn- yn-1 en valeur absolue < eps. Modifier la fonction en conséquence.
(define (newton x y eps)
(let ((z (/ (+ y (/ x y)) 2)))
(cond ((< (abs (- z y)) eps) z)
(else (newton x z eps)))))
Faire en version terminale la fonction (moyenne liste) qui calcule la moyenne d'une liste de nombres.
(define (moyenne liste)
(define (aux l s)
(cond ((null? l) (/ s (length liste)))
(else (aux (cdr l) (+ s (car l))))))
(if (null? liste) '() (aux liste 0)))
(define (moyenne liste)
(define (aux l s n)
(cond ((null? l) (/ s n))
(else (aux (cdr l) (+ s (car l)) (+ n 1)))))
(if (null? liste) '() (aux liste 0 0)))
Faire en version terminale la fonction (som-prod liste) qui calcule la somme et le produit d'une liste de nombres.
(define (som-prod liste)
(define (aux l s p)
(cond ((null? l) (list s p))
(else (aux (cdr l) (+ s (car l)) (* p (car l))))))
(if (null? liste) '() (aux liste 0 1)))
(define (som-prod liste)
(define (aux l res op)
(cond ((null? l) res)
(else (aux (cdr l) (op res (car l)) op))))
(if (null? liste)
'()
(list (aux liste 0 +) (aux liste 1 *))))
Faire une action : quand on appuie la touche "return" dans une case, le nombre est mis à 0 et réparti 1 à 1 dans les cases suivantes dans l'ordre inverse des aiguilles d'une montre. On fera une fonction (succ objet) qui donne l'objet text-field% successeur d'un objet donné. Les valeurs des objets text-field% seront converties en nombres avec number->string et string->number.
Faire la fonction qui réalise les prises : 2 ou 3 graines dans le camp adverse. Faire une fonction (camp objet) qui donne le camp d'un objet.
Scheme