Scheme
Scheme - TD n° 12
24 mai 2000
Classes et objets
Itérateurs
Welcome to DrScheme, version 101.
Language: Graphical Full Scheme (MrEd).
> (define truc%
(class object% ()
(public (toto 3)
(titi (lambda (x) (+ x 2)))
(tata (lambda (x y) (* x y)))))
(sequence (super-init))))
> (define truc1 (make-object truc%))
Donner les réponses de Scheme :
> truc% #<class:truc%> > truc1 #<object:truc%> > (ivar truc1 toto) 3 > (ivar truc1 titi) #<procedure:titi> > (send truc1 titi 5) 7 > (send truc1 tata 3 4) 12 > (send truc1 titi 3 4) procedure titi: expects 1 argument, given 2: 3 4 > (send truc1 tata 2) procedure tata: expects 2 arguments, given 1: 2 > (send truc1 toto 2) procedure application: expected procedure, given: 3; arguments were: 2
On définit une classe truc% et deux objets de cette classe :
> (define truc%
(class object% ()
(public (toto 3)
(set-toto (lambda (x) (set! toto x)))
(tutu (lambda (x) (+ x toto)))))
(sequence (super-init))))
> (define truc1 (make-object truc%))
> (define truc2 (make-object truc%))
Donner les réponses de Scheme :
> (ivar truc1 toto) 3 > (ivar truc1 set-toto) #<procedure:set-toto> > (send truc1 set-toto 4) > (ivar truc1 toto) 4 > (send truc1 tutu 3) 7 > (send truc1 set-toto 5) > (send truc1 tutu 3) 8 > (ivar truc1 toto) 5 > (ivar truc2 toto) 3 > (send truc2 tutu 3) 6
Faire une fonction (our-for-each fonction liste) qui applique l'effet de bord fonction à tous les éléments de liste :
> (our-for-each display '(1 2 3))
123
(define (our-for-each fonction liste)
(cond ((null? (cdr liste)) (fonction (car liste)))
(else (fonction (car liste))
(our-for-each fonction (cdr liste)))))
Faire une fonction (map-plat f l) qui applique f sur tous les éléments de l et donne la liste des résultats, en enlevant un niveau de parenthèse :
> (doubler 'a)
(a a)
> (map-plat doubler '(a b c))
(a a b b c c)
(define (map-plat f l)
(cond ((null? l) '())
(else (append (f (car l))
(map-plat f (cdr l))))))
(define (map-plat-term f l)
(define (aux l res)
(cond ((null? l) res)
(else (aux (cdr l) (append res (f (car l)))))))
(aux l '()))
Faire une fonction (somme f n) qui calcule:
(define (somme f n)
(cond ((= n 0) 0)
(else (+ (f n) (somme f (- n 1))))))
Faire une fonction (itere f n x) qui calcule:
(define (itere f n x)
(cond ((= n 0) x)
(else (+ x (itere f (- n 1) (f x))))))
(define (itere-term f n x)
(define (aux n x res)
(cond ((= n 0) res)
(else (aux (- n 1) (f x) (+ x res)))))
(aux n (f x) x))
Faire une fonction (genere f n x) qui calcule la liste:
(define (genere f n x)
(cond ((= n 0) (list x))
(else (cons x (genere f (- n 1) (f x))))))
(define (genere1 f n x)
(cond ((= n 0) (list x))
(else (cons x (map f (genere1 f (- n 1) x))))))
Pour certaines séries, on connaît un majorant du reste Rn = f(n+1) + f(n+2) + ... Par exemple, pour la série de terme 1/2n, on a Rn < 1/2n. Faire une fonction (somme-maj f maj eps) qui calcule:
(define (somme-maj f maj eps)
(define (aux k)
(cond ((< (maj k) eps) 0)
(else (+ (f k) (aux (+ k 1))))))
(aux 0))
2ème méthode (non terminale, mais plus rapide): On sépare la liste en deux sous-listes, celle des éléments plus petits que le premier élément, et celle des éléments plus grands. Puis on trie de la même manière les deux sous-listes.
Scheme