public class Rationnel implements Cloneable,Comparable<Rationnel> {
private int num; //le numerateur
private int den; //le denominateur
//Definir une methode qui test si un Rationnel est valide
public boolean estValide(){................................................................}
//Definir un constructeur de tous les objets de la classe Rationnel
public Rationnel(int num,int den){........................................................}
//Definir une methode qui test si un Rationnel est nul
public boolean estNul(){.................................}
//Definir les methodes estUnitaire (si num= den) et estEntier (si num % den =0)
public boolean estUnitaire(){......................................................}
public boolean estEntier(){........................................................}
//Redefinir la methode [Link] objects de type Rationnel a/b c/d sont egaux si
l’expression a*d-c*b est egale 0
public boolean equals(Object obj){.................................}
//Deux objets Rationnel a/b et c/d sont comparables comme suite: a/b > c/d si a*d-c*b>0;
a/b < c/d si a*d-c*b<0 ;sinon ils sont egaux
public int compareTo(Rationnel r){.................................}
//Redefinir la methode clone en declarant l’exception
public Rationnel clone()..................................{..............................}
public String toString() {.........................................................}
//Definir la methode additionner qui calcule et retourne la somme de deux objets Rationnels
public Rationnel additionner(Rationnel b){.................................}
//Definir la methode opposer qui calcule et retourne l’oppose d’un objet Rationnel donne .
L’oppose de a/b est -a/b
public Rationnel opposer(){.................................}
//Definir la methode inverser qui calcule et retourne l’inverse d’un objet Rationnel donne .
L’inverse de a/b est b/a
public Rationnel inverser(){.......................................................}
//Définir des méthodes qui effectuent les opérations usuelles sur les rationnel, à savoir,
la soustraction, la multiplication et la division de deux rationnels.
public Rationnel soustraire(Rationnel b){..........................................}
public Rationnel multiplier(Rationnel b){..........................................}
public Rationnel diviser(Rationnel b ){............................................}
public class Monome extends Paire<Integer,Rationnel> implements
Comparable<Monome>,Cloneable{
private int deg;
private Rationnel coeff;
//Definir un constructeur de tous les objets de type Monome et un constructeur de recopie
public Monome(int deg, Rationnel coeff){.................................}
public Monome(Monome m){.................................}
//Deux objets monomes sont egaux s’ils ont le meme degre
public boolean equals(Object obj){.................................}
//Un monome m1 de degre d1 est plus grand qu’un monome m2 de degre d2 si d1>d2;plus petit si
d1<d2; egaux sinon
public int compareTo(Rationnel r){.................................}
//Redefinir la methode clone en captant l’exception
public Monome clone(){.................................}
//Definir la methode additionner qui calcule et retourne la somme de deux monomes
public Monome additioner(Monome m){......................................................}
//Definir la methode multiplier qui calcule et retourne le produit de deux monomes
public Monome multiplier(Monome m){.................................}
//Definir la methode est nul qui test si un objet de type Monome est nul
public boolean estNul(){...........................................................}
𝑃 𝑛 𝑃+𝑛
//Calculer la puissance d’un monome .le monome puissance de a𝑋 est 𝑎 𝑋 ;
public Monome puissance(int n){....................................................}
public String toString() {.........................................................}
}
public class Polynome extends ArrayList<Monome> {
//Definir la methode localiser qui retourne dans une paire<Integer,Boolean> l’indice
d’insertition de l’objet de type Monome m donne en parametre et la valeur “false” si m
n’existe pas dans le polynome, sinon l’indice de position de m et la valeur “true”.Les
monomes sont disposes dans le polynome selon l’ordre naturel defini pour eux
public Paire<Integer,Boolean> localiser(Monome m){.................................}
//Redefinir la methode add de sorte que le resultat de l’insertion du monomerepresente sa
somme avec le polynome . le polynome ne doit pas contenir deux objets monomes qui sont
egaux. Le polynome reste trie dans l’ordre naturel (croissant) des monomes apres insertion
public boolean add(Monome m)
{//utiliser deux methodes 1er: avec utilisation de localiser
2eme: sans utilisation de localiser ............................}
//En utilisant un iterateur, definir une methode qui calcule la somme de deux objets de type
Polynome (Le resultat de la somme est calcule dans l’objet this )
public Polynome additionner(Polynome p){.................................................}
//Definir une methode qui calcule le produit d’un objet de type Monome avec un objet de type
polynome
public Polynome multiplier(Monome m){.................................................}
//Definir une methode qui calcule le produit de deux objets de type polynome
public Polynome multiplier(Polynome p){.................................................}
//Redefinir la methode [Link] polynomes sont egaux s’ils ont exactement les memes
monomes avec les memes coefficients
public boolean equals(Object obj){.................................................}
//Definir la methode suivante qui retourne l’ensemble des monomes verifiant p
public Polynome filtrer(Predicate<Monome> p){..........................................}
//Definir la methode suivante qui retourne l’ensemble des monomes auxquels on a applique la
fonction f
public Polynome maper(Function<Monome,Monome> f){........................................}
//Redefinir la methode clone
public ............ clone(){............................................}
//Completer la methode suivante qui verifie si q est une composante additive de p *voir an.1
public ........................ composanteAdditive(Polynome p,polynome q){...............}
//Deux polynomes sont egaux s’ils ont exactement les memes monomes avec les memes
coefficients. Definir la methode sontEgaux qui teste si deux polynomes sont egaux
public ........................ sontEgaux(Polynome p){...................................}
//En utilisant une expression Lambda, definir la methode suivante qui retourne un polynome
constitué des plus grands monomes d’un polynome donné *voir annex1
public Polynome plusGrandsMonomes(){.................................................}
//Definir la methode suivante qui retourne une paire contenant un polynome et son miroir
*voir annex1
public Paire<Polynome,Polynome> polynomeMiroir(){.........................................}
//Definir la methode suivante qui retourne l’ensemble des monomes verifiant p
public Polynome filtrer(Predicate<Paire<Integer,Rationnel>> p){.................}
//Definir la methode suivante qui ,d’un polynome donne , effectue l’extraction des deux
polynomes, le premier ayant tous les monomes de degres pairs, le deuxieme ayant tous les
monomes de degres impaires .Ce couple de polynome doit etre retourne dans un paire.
public Paire<Polynome,Polynome> paireImpaire(){...........................................}
//Definir la methode suivante qui calcule et retourne la somme des deux objets polynomes
contenus dans le paire p
public static Polynome additionnerPolynomePaire(Paire<Polynome,Polynome> p){..............}
//Definir la methode suivante qui test si les deux polynomes de la paire sont egaux
public static boolean polynomePaireEgaux(Paire<Polynome,Polynome> p){.................}