Durée de l'épreuve : 2h. Tous documents papier autorisés. Les questions, bien que liées, peuvent être traitées indépendamment. Efforcez vous à expliquer les différents concepts abordés dans chaque question.

Pour analyser la cinématique des systèmes mécaniques plans, on peut utiliser différents outils mathématiques (vecteurs, torseurs, équations en projection sur x et y...). Il y en a une assez amusante qui consiste à utiliser des matrices dites "homogènes". Tout point (appartenant à une pièce en général) est défini par une matrice [3,1] (3 lignes, 1 colonne), contenant de haut en bas : sa coordonnée en x, en y, et la constante 1 (un). Tout mouvement d'une pièce est défini par une matrice [3,3] dont la dernière ligne est obligatoirement composée des constantes 0, 0, 1. Evidemment, il est inutile dans ce sujet de comprendre pourquoi on procède ainsi, il vous suffit de l'accepter.

Si une pièce bouge (mouvement ), alors tout point initialement en

se retrouvera en tel que = * donc

Les matrices homogènes ont les particularités suivantes : l'application d'un mouvement à un point donne toujours un point (troisième ligne à 1), l'inverse d'une matrice homogène (inversible) est homogène, le produit de deux matrices homogènes (qui correspond à la composition de deux mouvements) est une matrice homogène :

*=

La rotation d'une pièce, autour du point (0,0), a pour matrice .

La translation de c suivant x et de f suivant y a pour matrice .

La matrice Identité correspond à l'immobilisme (et est également homogène).

Question 1 : Définissez l'objet « matrice ». Il contient 6 flottants appelés a,b,c,d,e et f (inutile de stocker des constantes en plus, puisqu'elles sont constantes). Ceux qui veulent utiliser des tableaux ou des matrices ont le droit de le faire, mais six flottants distincts me suffisent largement. Vous définirez également les accesseurs en écriture suivants :

• set qui reçoit 6 arguments, correspondant aux 6 composantes,
• set_rotation qui reçoit un argument (une valeur d'angle), et fixe les 6 composantes de la matrice pour correspondre à cette rotation (supposée autour du centre du repère 0,0),
• set_translation qui reçoit deux arguments (translation en x et y),
• set_identite qui ne reçoit aucun argument et rend la matrice unitaire.

Par contre, pour éviter de vous faire perdre du temps, vous n'écrirez pas d'accesseur en lecture, mais vous donnerez un accès direct aux 6 composantes.

Question 2 : Définissez une méthode de la classe matrice nommée "produit", qui reçoit en arguments deux matrices et calcule leur produit : si l'on a déclaré trois matrices A, B, C, appeler "C.produit(A,B);" met A*B dans C. Ceci correspond à la composition des deux mouvements.

Question 3 : Définissez maintenant un objet "point". Il contient deux coordonnées (il est inutile de stocker la constante 1). Mais ces deux coordonnées seront "privées", il faudra donc prévoir un accesseur en lecture pour chaque coordonnée, et un accesseur en écriture (auquel on donne les deux coordonnées). Mais surtout définissez la méthode "bouger" qui reçoit en argument une matrice, et modifie le point actuel en lui appliquant la matrice.

Question 4 : Pour effectuer une rotation autour d'un point (x,y) autre que le centre du repère, la méthode la plus simple est de déplacer la pièce de -x,-y puis effectuer la rotation puis déplacer de +x,+y. Rajoutez à la classe matrice un accesseur en écriture nommé "set_rot_gene" qui reçoive en argument un angle et un objet point, et réalise cette rotation. Vous utiliserez au maximum les méthodes déjà définies.

Question 5 : Dans le cas d'un système mécanique, on traite généralement une chaîne cinématique, avec plusieurs liaisons (mouvements de rotation et translation uniquement). Nous allons traiter le cas d'une chaîne simple, que l'on stockera sous forme d'une liste chaînée de matrices. Supposons avoir rajouté comme attribut public de la classe matrice "matrice * suiv;" (en plus des 6 float). Supposons également avoir déclaré :

typedef matrice * ptr;
class chaine
 {
  ptr prem;
  public:
  void creation(void);
 };
void chaine::creation(void)
 {
  ptr tmp,tmp2;
  int i;
  prem=new matrice;
  prem->set_rotation(3.14159265358979);
  tmp=new matrice;
  prem->suiv=tmp;
  tmp->set_translation(2,2);
  for (i=0;i<3;i++)
   {
    tmp2=new matrice;
    tmp2->set_identite();
    tmp->suiv=tmp2;
    tmp=tmp2;
   }
  tmp->suiv=NULL;
 }

expliquez moi (en particulier avec un dessin) ce que l'on trouvera en mémoire après avoir exécuté ceci :

  chaine c;
  c.creation();

Question 6 : Ecrivez une méthode nommée "afficher" qui affiche toutes les matrices d'une chaîne définie comme ci-dessus (mais dans le cas général, pas créée de manière figée comme ici). Vous pouvez considérer comme sûr que l'attribut "suiv" du dernier élément de la chaîne contient "NULL".

Je vous propose une ébauche de solution.

Ci-dessous, l'histogramme des notes du module, ainsi que des trois notes qui la composent (cc1, cc2 et TP).

Patrick TRAU, ULP - IPST fev 06