cours  |  td  |  examens  |  doc  |  liens  |  horaires
 Scheme

Université de Caen - UFR de Sciences
Deug MIAS-MASS
Marc Chemillier

Scheme - TD n° 12
24 mai 2000

Classes et objets
Itérateurs




  • Exercices : (1h1/2)

    1. On définit une classe truc% et un objet de cette classe :
      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
      

    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
      

    3. 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)))))
      
    4. 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 '()))
      
    5. Faire une fonction (somme f n) qui calcule:
      f(1) + f(2) + ... + f(n)
      (define (somme f n)
        (cond ((= n 0) 0)
              (else (+ (f n) (somme f (- n 1))))))
      
    6. Faire une fonction (itere f n x) qui calcule:
      x + f(x) + f(f(x)) + ... + fn(x)
      (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))
      
    7. Faire une fonction (genere f n x) qui calcule la liste:
      (x f(x) f(f(x)) ... fn(x))
      (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))))))
      
    8. 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:
      f(1) + f(2) + ... + f(n)
      jusqu'à ce que le majorant du reste défini par la fonction maj soit inférieur à eps.
      (define (somme-maj f maj eps)
        (define (aux k)
          (cond ((< (maj k) eps) 0)
                (else (+ (f k) (aux (+ k 1))))))
        (aux 0))
      

  • Avec machines : (1h1/2) Algorithmes de tri


    cours  |  td  |  examens  |  doc  |  liens  |  horaires
     Scheme