Un module de calculs génériques pour diverses structures algébriques

Etudier les paquets fournis suivants : tp4.entiers et tp4.rationnels.

Créer une classe de test, tp4.Test, et réaliser le scénario suivant dans la fonction principale. Pour créer ces différents nombres, utiliser des fabriques.

• Créer quatre entiers relatifs valant -3, 3, 2 et 1 et les stocker dans quatre variables.
• Afficher leur valeur à l'écran, ainsi que la valeur attendue (l'oracle) suivant le format suivant : oracle ? valeur. On procédera toujours ainsi pour l'affichage.
• Créer un entier naturel valant 3.
• Afficher sa valeur.
• Créer deux rationnels, valant 2.0 et 0.5.
• Afficher leur valeur.

Etudier le paquet fourni tp4.matrices.

• Afficher les valeurs des deux dimensions fournies.

Nous allons construire un module générique de calculs. Ce module comportera des fonctions réalisant des calculs sur les éléments de différentes structures algébriques, de manière générique. On travaille dans le paquet tp4.algebre.

• Définir une classe module Calculs.
• Y déclarer la fonction d'exponentiation puissance la plus générale possible, avec pour exposant un Nat.
• L'implémenter récursivement en utilisant l'identité \(x^n = x . x^{n-1}\).
• Définir une seconde fonction puissance, avec pour exposant un Z.
• Tester les deux fonctions en réalisant les calculs suivants.
  • Entier naturel trois au cube
  • Moins trois au cube
  • Rationnel deux au cube
  • Rationnel deux au cube inversé
  • Rationnel un-demi au cube
• Définir des variantes des fonctions puissance utilisant l'accélération logarithmique : elles reposent sur les deux identités \(x^{2.n} = (x^{2})^{n}\) et \(x^{2.n+1} = (x^{2})^{n}.x\). On les nommera puissanceLog.
• Tester les deux nouvelles fonctions comme précédemment.

On travaille dans le paquet tp4.matrices.

• Définir trois interfaces génériques
  • FabriqueMatriceCarree
  • AssembleurMatriceCarree et
  • MatriceCarree.

  Elles doivent être quantifiées universellement ainsi : pour tout type T sous-type de Dimension et pour tout type A qui est un AnneauUnitaire.

• Préciser les interfaces parentes de l'interface MatriceCarree, conformément à la spécification ci-dessus.
• Déclarer les méthodes de l'interface FabriqueMatriceCarree, suivant la spécification donnée ci-dessus.
• Déclarer les deux méthodes suivantes dans l'interface AssembleurMatriceCarree.
  • void placer(int l, int c, A x)
  • MatriceCarree<T, A> terminer()

On travaille dans le paquet tp4.matrices.

• Définir une classe abstraite générique AnneauUnitaireDesMatricesCarrees implémentant partiellement l'interface MatriceCarree. La quantifier universellement comme l'interface implémentée.
• Implémenter les cinq méthodes correspondant aux calculs algébriques, zero, somme, oppose, produit et un, en utilisant les méthodes abstraites, soit les fabriques et les accesseurs. Pour les méthodes somme, produit et oppose, utiliser un assembleur pour produire la matrice résultat à partir de la matrice initialement nulle.

On travaille dans le paquet tp4.matrices. On implémente les matrices carrées en utilisant un tableau de type ArrayList, sous-type de List.

• Définir une classe concrète générique MatriceCarreeParArrayList implémentant l'interface MatriceCarree par héritage de la classe abstraite AnneauUnitaireDesMatricesCarrees. La quantifier universellement comme l'interface implémentée.
• Définir l'état ainsi.

  private List<A> tableau;
  private Dimension ordre;
  private int ordreInt; // Calculé à partir de this.ordre
  

• Définir les méthodes protected suivantes.

  protected void initialiser(A x) {
          for(int l = 0; l < this.ordreInt; l++){
                  for(int c = 0; c < this.ordreInt; c++){
                          this.tableau.add(x); // Ajout en fin de liste
                  }
          }       
  }
  protected void setVal(int l, int c, A x) {
          this.tableau.set(position(l, c), x); // Pré-condition : position dans la liste
  }
  protected int position(int l, int c) {
          return c + l * this.ordreInt; // Par ligne
  }
  

  Elles sont à utiliser par la suite.

• Définir le constructeur suivant à l'aide des commentaires.

  public MatriceCarreeParArrayList(Dimension ordre, UnifereAddition<A> genZero) {
          // Initialiser les attributs. 
          ...
          // Initialiser à zéro les éléments de la matrice.
          ...
  }
  

• Définir les accesseurs ordre et val.
• Définir les deux fabriques creerMatriceZero et creerMatriceUnite. Utiliser un assembleur de type AssembleurMatriceCarree, qui initialement contient une matrice remplie de zéros.
• Définir la méthode getAssembleur en renvoyant null : on la définira après avoir défini une implémentation de AssembleurMatriceCarree.
• Définir la méthode toString ainsi.

  public String toString(){
          StringBuilder r = new StringBuilder("");
          for(int l = 0; l < this.ordreInt; l++){
                  r.append('[');
                  for(int c = 0; c < this.ordreInt; c++){
                          r.append(this.val(l,  c).toString());
                          r.append(' ');
                  }
                  r.append(']');
          }
          return r.toString();
  }
  

On travaille dans le paquet tp4.matrices. On implémente les assembleurs associés aux matrices carrées représentées par des tableaux de type ArrayList.

• Définir une classe concrète générique AssembleurMatriceCarreeParArrayList implémentant l'interface AssembleurMatriceCarree. La quantifier universellement comme l'interface implémentée.
• Définir un attribut privé de type MatriceCarreeParArrayList<T, A>. On utilise comme type la classe d'implémentation et non l'interface pour pouvoir accéder à l'accesseur en écriture setVal, qui ne fait pas partie de l'interface. Cet accesseur n'est utilisé que lors de l'assemblage.
• Définir le constructeur associé à l'attribut.
• Définir la méthode placer, qui place un élément dans la matrice sous-jacente à la position indiquée.
• Définir la méthode terminer de manière à renvoyer la matrice sous-jacente. Pour éviter que cette matrice puisse être modifiée après son assemblage, mettre à null l'attribut avant de retourner le résultat.
• Dans la classe MatriceCarreeParArrayList, implémenter la méthode getAssembleur en appelant le constructeur de la classe AssembleurMatriceCarreeParArrayList. Passer en argument une nouvelle matrice de type MatriceCarreeParArrayList.

On travaille dans la classe tp4.Test.

• Compléter la fonction principale en suivant les commentaires. Tous les objets créés sont à stocker dans des variables. On veillera à utiliser des noms significatifs.

public static void main(String[] args) {
      // Tests avec les nombres faits précédemment.

      // Créer une fabrique de matrices carrées d'ordre deux sur Z. 

      // Créer la matrice (d'ordre deux) nulle. 
      // Afficher son ordre.
      // Afficher sa valeur.

      // Récupérer un assembleur d'une matrice carrée.
      // Placer sur la diagonale deux (entier relatif).
      // Produire la matrice ainsi initialisée.
      // Afficher sa valeur.
      // Calculer son cube en utilisant les fonctions puissance 
      //   et afficher le résultat.

      // Créer la matrice (d'ordre deux) unité. 
      // Afficher sa valeur.
      // Afficher le résultat de l'appel de zero.
      // Afficher le résultat de l'appel de un.
      // Calculer la somme de un et zéro.
      // Afficher le résultat.
      // Calculer le produit de un par un.
      // Afficher le résultat.
      // Calculer l'opposé de un.
      // Afficher le résultat.

      // Créer une fabrique de matrices carrées d'ordre trois sur Z. 
      // Créer la matrice (d'ordre trois) nulle. 
      // Afficher son ordre.
      // Afficher le résultat de l'appel de un.
      // Faire si possible la somme d'une matrice d'ordre deux et 
      //    d'une matrice d'ordre trois.
}