Michel Volle à Laurent Bloch, 17 avril 2006

J'ai le plaisir de t'envoyer ci-joint le programme d'analyse des correspondances, avec la notice explicative et la présentation des résultats sous Excel.
Comment le trouves-tu ? As-tu des corrections à suggérer ?

Laurent Bloch à Michel Volle, 17 avril 2006

Il me semble qu'il n'y a pas de honte à recourir à Excel, mais j'ai vu sur le site de DrScheme des bibliothèques aux noms prometteurs, tels que PlotScheme. Hélas je n'ai pas trouvé d'accès aux programmes ! Peut-être aussi peut-on aller voir ici avec profit :
http://repository.readscheme.org/ftp/papers/sw2003/PLoTScheme.pdf

Laurent Bloch à Michel Volle, 19 avril 2006

Ton code me semble très propre. Je ne suis pas surpris de ta préférence pour la forme lambda.

Je pense que tu aurais intérêt à utiliser les vecteurs de Scheme à la place des listes, ce n'est pas très compliqué, cela convient bien à ton problème, et tu aurais de meilleurs performances. Une grande partie de ton code consiste à couler des vecteurs dans des listes, ce que tu gagnerais.

Ensuite, tu devrais utiliser, pour parcourir tes vecteurs, la forme DO, qui a une syntaxe à coucher dehors, mais une fois qu'on s'y est habitué elle est très pratique.

Ta procédure INV existe dans le langage sous le nom de REVERSE, mais avec les vecteurs tu n'en auras plus besoin ; en effet l'avantage des vecteurs, c'est que l'accès aux éléments est en temps constant, quel que soit leur rang :

(define V1 (vector 1 2 3 4 5))

(vector-ref V1 0) => 1
(vector-ref V1 4) => 5

(vector-set! V1 3 18) => #unspecified
V1 => #(1 2 3 18 5)

Si tu veux écrire INV à la main, une autre solution (mais avec les
vecteurs, plus besoin !) :

(define (concatener-2 L1 L2)
(if (null? L1)
L2
(cons (car L1)
(concatener-2 (cdr L1) L2))))

(define (retourner L)
(if (null?  L)
'()
(concatener-2 (retourner (cdr L))
(list (car L)))))

Dans le langage, CONCATENER = APPEND

Pour écrire la somme des éléments d'un vecteur :

(define vecteur:somme
   (lambda (V)
          ;; la première parenthèse du DO contient les liaisons :
              ;; i est défini avec la valeur initiale 0, à chaque
              ;; itération il se voit affecter (+ 1 i)
      (do ((i 0 (+ 1 i))
              ;; la-somme est définie avec la valeur initiale 0,
              ;; à chaque itération on lui ajoute (vector-ref V i)
          (la-somme 0 (+ la-somme (vector-ref V i))))
              ;; on s'arrête lorsque i atteint la valeur
              ;; (vector-length V)
         ((= i (vector-length V))
              ;; et alors le résultat est dans la-somme
          la-somme))))

Ce DO est simple : il n'a pas de corps, parce qu'il n'en a pas besoin, c'est tout le charme.

Laurent Bloch à Michel Volle, 18 octobre 2007

J'admire ton courage pour lancer le projet ANDON. Je suis bien sûr prêt à t'aider. Mon mois de novembre est un peu chargé, mais après le 10 décembre je serai plus disponible.

D'après le souvenir de tes programmes antérieurs : tu devrais investir dans les apprentissages suivants : création de programmes Scheme compilables, entrées-sorties sur les fichiers. J'ai la faiblesse de penser que mon modeste bouquin de Scheme aborde ces sujets, laissés de côté par les autres auteurs de livres schemiens.

Ludovic Lebart à Michel Volle, 24 octobre 2007

Le langage adapté dans l'esprit du projet ANDON est R, il y a notamment le bouquin de Fionn Murtagh sur l'AFC en R et Java  (voir avec Google...)