Classes mathématiques

En mathématiques, un intervalle (réel) ([real] interval en anglais) est l'ensemble de tous les nombres réels compris entre deux d'entre eux, qui constituent respectivement la borne inférieure (a ci-dessous) et la borne supérieure (b ci-dessous) de l'intervalle.

Un intervalle peut être ouvert ou fermé de chaque côté (à gauche et à droite), ce qui détermine si la borne correspondante est incluse ou non dans l'ensemble : si l'ensemble est fermé d'un côté, la borne correspondante en fait partie, sinon elle n'en fait pas partie.

Il existe donc quatre sortes d'intervalles que l'on note, définit et nomme de la manière suivante :

1. \(]a,b[\,= \{ x\in\Bbb{R}\ |\ a \lt x \lt b\}\) : intervalle ouvert,
2. \(]a,b]\,= \{ x\in\Bbb{R}\ |\ a \lt x \le b\}\) : intervalle semi-ouvert à gauche,
3. \([a,b[\,= \{ x\in\Bbb{R}\ |\ a \le x \lt b\}\) : intervalle semi-ouvert à droite,
4. \([a,b]\,= \{ x\in\Bbb{R}\ |\ a \le x \le b\}\) : intervalle fermé.

Un intervalle est de plus dit non trivial s'il contient plus d'un élément, c-à-d si a < b. La taille d'un tel intervalle est simplement la différence entre sa borne supérieure et sa borne inférieure, à savoir b – a.

Dans le cadre de ce projet, nous n'utiliserons que deux types d'intervalles, les semi-ouverts à droite et les fermés, toujours non triviaux. Nous définirons de plus deux fonctions sur ces intervalles :

1. l'écrêtage, défini sur les intervalles fermés,
2. la réduction, définie sur les intervalles semi-ouverts à droite.

Le but de ces deux fonctions est de ramener une valeur quelconque à la valeur de l'intervalle qui lui correspond, mais elles le font de manière différente, comme expliqué ci-après.

Une fonction polynomiale de degré n est une fonction f ayant la forme suivante :

\[ f(x) = c_n\,x^n + c_{n-1}\,x^{n-1} + \cdots + c_1\,x + c_0 \]

où les \(c_j\) sont des nombres réels, appelés les coefficients de la fonction. Cette fonction peut s'écrire de manière équivalente sous la forme dite de Horner :

\[ f(x) = ((\cdots(c_n\,x + c_{n-1})\,x + \cdots) + c_1)\,x + c_0 \]

La forme de Horner présente l'avantage de ne nécessiter aucune élévation à la puissance, et d'être donc plus efficace à calculer.

Les angles peuvent être représentés au moyen de différentes unités, par exemple les radians ou les degrés, ayant chacune leurs avantages et inconvénients.

Ainsi, pour les calculs, l'unité la plus naturelle est le radian. C'est d'ailleurs la seule unité utilisée par les méthodes trigonométriques (sinus, cosinus, etc.) de Java et de la plupart des langages de programmation. Par contre, pour les êtres humains, les radians sont peu agréables à utiliser. Pour cette raison, deux autres unités leur sont souvent préférées en astronomie : les degrés et les heures.

Les sections qui suivent décrivent les trois unités d'angle susmentionnées.

Avant de commencer à programmer, il faut vous assurer que la version 11 de Java est bien installée sur votre ordinateur, car c'est celle qui sera utilisée pour ce projet.

Si vous n'avez pas encore installé cette version, rendez-vous sur le site Web du projet AdoptOpenJDK, téléchargez le programme d'installation correspondant à votre système d'exploitation (macOS, Linux ou Windows), et exécutez-le. Ensuite, si vous utilisez Eclipse plutôt qu'IntelliJ, lisez le guide Configurer Eclipse et suivez les indications qui s'y trouvent.

Fréquemment, les méthodes d'un programme s'attendent à ce que leurs arguments satisfassent certaines conditions. Par exemple, une méthode déterminant la valeur maximale d'un tableau d'entiers s'attend à ce que ce tableau ne soit pas vide.

De telles conditions sont souvent appelées préconditions car elles doivent être satisfaites avant l'appel d'une méthode : c'est à l'appelant de s'assurer qu'il n'appelle la méthode qu'avec des arguments valides.

En Java, la convention veut que chaque méthode vérifie ses préconditions et lève une exception — souvent IllegalArgumentException — si l'une d'entre elles n'est pas satisfaite. Par exemple, une méthode max calculant la valeur maximale d'un tableau d'entiers pourrait commencer ainsi :

int max(int[] array) {
  if (! (array.length > 0))
    throw new IllegalArgumentException();
  // … reste du code
}

(Notez au passage que la méthode max ne déclare pas qu'elle lève potentiellement IllegalArgumentException au moyen d'une clause throws, car cette exception est de type unchecked.)

La première classe à réaliser dans le cadre de ce projet a pour but de faciliter l'écriture de telles préconditions. En l'utilisant, la méthode ci-dessus pourrait être simplifiée ainsi :

import static ch.epfl.rigel.Preconditions.checkArgument;
int max(int[] array) {
  checkArgument(array.length > 0);
  // … reste du code
}

Cette classe est nommée Preconditions et appartient au paquetage ch.epfl.rigel. Elle est publique et finale et n'offre rien d'autre que deux méthodes statiques décrites plus bas. Elle a toutefois la particularité d'avoir un constructeur par défaut privé :

public final class Preconditions {
  private Preconditions() {}
  // … méthodes
}

Le but de ce constructeur privé est de rendre impossible la création d'instances de la classe, puisque cela n'a clairement aucun sens — elle ne sert que de conteneur à un ensemble de méthodes statiques. Dans la suite du projet, nous définirons plusieurs autres classes du même type, que nous appellerons dès maintenant classes non instanciables.

Les deux méthodes publiques (et statiques) de la classe Preconditions sont :

• void checkArgument(boolean isTrue), qui lève l'exception IllegalArgumentException si son argument est faux, et ne fait rien sinon,
• double checkInInterval(Interval interval, double value), qui lève l'exception IllegalArgumentException si value n'appartient pas à interval, et retourne value sinon.

Notez que pour écrire la seconde méthode, il vous faut d'abord écrire la classe Interval décrite à la §3.3.

La classe Interval du paquetage ch.epfl.rigel.math, publique, abstraite et immuable, représente un intervalle. Elle a pour but de servir de classe mère aux deux classes représentant respectivement un intervalle fermé et un intervalle semi-ouvert à droite, décrites plus bas (§3.4 et §3.5).

La classe Interval possède un unique constructeur, protégé, qui prend en argument les bornes de l'intervalle et les stocke dans des attributs privés et finaux.

En plus de ce constructeur, elle offre les méthodes publiques suivantes :

• double low(), qui retourne la borne inférieure de l'intervalle,
• double high(), qui retourne la borne supérieure de l'intervalle,
• double size(), qui retourne la taille de l'intervalle.

De plus, la classe Interval définit une méthode abstraite que les sous-classes doivent redéfinir :

• boolean contains(double v), qui retourne vrai ssi — si et seulement si — la valeur v appartient à l'intervalle.

Finalement, la classe Interval redéfinit les méthodes hashCode et equals de Object afin qu'elles lèvent l'exception UnsupportedOperationException. Pour garantir qu'aucune sous-classe ne les redéfinira, ces méthodes sont déclarées finales.

Il peut paraître étrange de demander que la méthode equals (et hashCode, qui est liée à equals et sera examinée plus tard dans le cours) lève une exception. Après tout, n'est-il pas raisonnable de tester si deux intervalles sont égaux ?

Mathématiquement, la réponse est clairement oui : deux intervalles sont égaux si — et seulement si — ils sont du même type et leurs bornes sont égales.

En Java, les choses sont plus délicates car les bornes ne sont pas vraiment des nombres réels, mais une approximation sous forme de nombres à virgule flottante — de type float ou double. Or cette approximation a une précision limitée, qui implique que certaines valeurs mathématiquement égales ne le sont pas lorsqu'on les représente au moyen de nombres à virgule flottante.

Par exemple, mathématiquement, l'égalité suivante est vraie :

\[ 0.1 + 0.2 = 0.15 + 0.15 \]

Or en Java (et dans la plupart des langages de programmation actuels), cette même égalité est fausse ! Ainsi, l'extrait de programme suivant affiche false et pas true comme on pourrait le penser :

System.out.println(0.1 + 0.2 == 0.15 + 0.15);

Pour cette raison, dans ce projet nous avons choisi de ne jamais tester l'égalité de nombres à virgule flottante.

Une conséquence de ce choix est que la méthode equals de Interval ne peut rien faire d'autre que lever une exception, car elle n'a pas le droit de tester l'égalité des bornes des intervalles à comparer, comme elle devrait théoriquement le faire. Cela sera vrai pour de nombreuses autres classes de ce projet, à commencer par toutes celles dont au moins un attribut est un nombre à virgule flottante.

On peut se demander s'il n'aurait pas été préférable de simplement hériter les méthodes equals et hashCode de Object, sans les redéfinir. Malheureusement, cette solution n'est pas bonne non plus, car la notion d'égalité aurait alors été basée sur l'identité des objets, ce qui n'a pas vraiment de sens pour une classe immuable, comme nous le verrons ultérieurement dans le cours.

La classe ClosedInterval du paquetage ch.epfl.rigel.math, publique, finale et immuable, représente un intervalle fermé. Elle hérite bien entendu de la classe Interval.

Son constructeur est privé, mais elle offre des méthodes publiques et statiques de construction permettant de créer un intervalle fermé de deux manières différentes :

• ClosedInterval of(double low, double high), qui retourne un intervalle fermé allant de low à high, ou lève IllegalArgumentException si la borne inférieure low n'est pas (strictement) plus petite que la borne supérieure high,
• ClosedInterval symmetric(double size), qui retourne un intervalle fermé centré en 0 et de taille size, ou lève IllegalArgumentException si la taille n'est pas (strictement) positive.

En plus de la définition de la méthode contains, la classe ClosedInterval définit la méthode suivante :

• double clip(double v), qui écrête son argument à l'intervalle (voir §2.1.1).

Finalement, la classe ClosedInterval redéfinit la méthode toString de Object afin qu'elle retourne la représentation textuelle de l'intervalle, formée de la borne inférieure et de la borne supérieure, séparées par une virgule et entourées de crochets droits. (Voir à ce sujet les conseils de programmation qui suivent.)

La classe RightOpenInterval du paquetage ch.epfl.rigel.math, publique, finale et immuable, représente un intervalle semi-ouvert à droite. Elle hérite bien entendu de la classe Interval.

Tout comme ClosedInterval, son constructeur est privé mais elle offre les deux mêmes méthodes de construction statiques que ClosedInterval, à savoir of et symmetric, mais qui retournent bien entendu un intervalle semi-ouvert à droite.

En plus de la définition de la méthode contains, la classe RightOpenInterval définit la méthode publique suivante :

• double reduce(double v), qui réduit son argument à l'intervalle (voir §2.1.2).

Finalement, la classe RightOpenInterval redéfinit la méthode toString de Object de manière similaire à la classe ClosedInterval, la différence étant bien entendu que le crochet terminant cette chaîne est ouvrant ([) et pas fermant (]).

Dans ce projet, nous avons choisi de représenter les angles au moyen de simples nombres à virgule flottante de type double, dont la valeur est celle de l'angle, généralement exprimée en radians.

Il aurait bien entendu aussi été possible de définir une classe représentant un angle. Cette solution, peut-être plus conforme à la « philosophie orientée-objet », aurait toutefois été un peu lourde à l'usage, raison pour laquelle nous ne l'avons pas retenue.

L'inconvénient principal de la solution choisie est qu'il n'y a aucun moyen de connaître l'unité utilisée pour représenter un angle donné. Dès lors, il est très important de toujours avoir en tête, lorsqu'on écrit du code manipulant des angles, l'unité dans laquelle ils sont exprimés. En effet, les erreurs d'unités peuvent avoir des conséquences fâcheuses¹.

Dès lors, nous adopterons la convention suivante : dans la mesure du possible, tous les angles du projet seront représentés en radians. Lorsqu'un angle doit être représenté dans une autre unité, celle-ci sera rappelée au moyen d'un suffixe dans le nom de la variable ou méthode concernée : deg pour les angles exprimés en degrés, hr pour ceux exprimés en heures. Pensez à suivre cette convention dans votre code pour le rendre plus facile à comprendre et éviter les erreurs !

Le fait que nous ayons choisi de représenter les angles par de simples valeurs de type double implique qu'il n'existe pas de classe représentant un angle. Il est toutefois utile d'avoir à disposition des méthodes de manipulation d'angles, et nous n'avons pas d'autre choix, en Java, que de les placer dans une classe, sous forme de méthodes statiques.

Cette classe est la classe Angle du paquetage ch.epfl.rigel.math, et elle est publique, finale et non instanciable. Son seul but est, comme dit ci-dessus, de regrouper les méthodes et constantes permettant de travailler sur des angles représentés par des valeurs de type double.

Cette classe définit la constante publique, finale et statique suivante :

• double TAU, qui représente la constante τ.

De plus, elle offre les méthodes publiques et statiques suivantes :

• double normalizePositive(double rad), qui normalise l'angle rad en le réduisant à l'intervalle [0,τ[,
• double ofArcsec(double sec), qui retourne l'angle correspondant au nombre de secondes d'arc donné, qui peut être quelconque (y compris négatif),
• double ofDMS(int deg, int min, double sec), qui retourne l'angle correspondant à l'angle deg​° min​′ sec​″, ou lève IllegalArgumentException si les minutes données ne sont pas comprises entre 0 (inclus) et 60 (exclus), ou si les secondes ne sont pas comprises entre 0 (inclus) et 60 (exclus),
• double ofDeg(double deg), qui retourne l'angle correspondant à l'angle en degrés donné,
• double toDeg(double rad), qui retourne l'angle en degrés correspondant à l'angle donné,
• double ofHr(double hr), qui retourne l'angle correspondant à l'angle en heures donné,
• double toHr(double rad), qui retourne l'angle en heures correspondant à l'angle donné.

La classe Polynomial du paquetage ch.epfl.rigel.math, publique, finale et immuable, représente une fonction polynomiale.

Son constructeur est privé, mais elle offre une méthode de construction publique et statique :

• Polynomial of(double coefficientN, double... coefficients), qui retourne la fonction polynomiale avec les coefficients donnés, ordonnés par degré en ordre décroissant, ou lève l'exception IllegalArgumentException si le coefficient de plus haut degré (coefficientN) vaut 0.

Étant donné que les coefficients sont passés à la méthode of par ordre décroissant, l'appel suivant :

Polynomial.of(4, -1, 0, 2);

retourne l'objet représentant la fonction polynomiale suivante : \[ 4\,x^3 - x^2 + 2 \] En d'autres termes, le dernier coefficient est toujours celui de degré 0, l'avant-dernier celui de degré 1, et ainsi de suite.

La raison pour laquelle le premier coefficient (coefficientN) est passé séparément des autres est simplement que cela rend impossible l'appel de cette méthode avec 0 arguments, ce qui serait incorrect. Cette petite astuce est souvent utilisée en Java pour définir des méthodes acceptant un nombre variable mais non nul d'arguments, et il est bon de la connaître.

Il faut toutefois noter que même si les coefficients sont passés à la méthode of au moyen d'une paire d'arguments — coefficientN, de type double, et coefficients, de type double[] —, ils doivent être stockés dans un tableau unique par la classe Polynomial.

En plus de la méthode de construction susmentionnée, Polynomial offre la méthode publique suivante :

• double at(double x), qui retourne la valeur de la fonction polynomiale pour l'argument donné. Attention : pour des raisons de performance, cette valeur doit impérativement être calculée au moyen de la forme de Horner, sans aucune élévation à la puissance.

De plus, la classe Polynomial redéfinit la méthode toString de Object pour qu'elle retourne la représentation textuelle de la fonction polynomiale. Cette chaîne doit être minimale, dans le sens où elle ne doit pas inclure de coefficient, exposant ou signe superflu. Cette contrainte complique quelque peu sa mise en œuvre, mais constitue un excellent exercice de programmation.

Finalement, la classe Polynomial redéfinit les méthodes hashCode et equals pour qu'elles lèvent l'exception UnsupportedOperationException.

Pour vous aider à démarrer ce projet, nous vous fournissons exceptionnellement une archive Zip contenant des tests unitaires JUnit pour cette étape.

Pour pouvoir utiliser ces tests, il vous faut :

1. les importer dans votre projet (instructions pour IntelliJ ou Eclipse),
2. ajouter la bibliothèque JUnit à votre projet (instructions pour IntelliJ ou Eclipse).

Une fois les tests exécutés avec succès, il vous reste à documenter la totalité des entités publiques (classes, attributs et méthodes) définies dans cette étape, au moyen de commentaires Javadoc, comme décrit dans le guide consacré à ce sujet. Vous pouvez écrire ces commentaires en français ou en anglais, en fonction de votre préférence, mais vous ne devez utiliser qu'une seule langue pour tout le projet.