cahier d`exercices 2007

Projet intégrateur : informatique
2nde thématique transversale
Comportement d’un lève-charge
CB1 2007-2008
1 Objectifs et déroulement de la session informatique
1.1 Objectifs
Pour la seconde thématique transversale du projet intégrateur, l’objectif de la session informatique
vise à réaliser un outil de calcul et de simulation de la trajectoire d’une masse suspendue à un
système de lève-charge. Grâce à cet outil, vous déterminerez le premier instant auquel la trajectoire de
la masse coupe théoriquement la barrière lumineuse de votre montage. Vous pourrez alors reconstituer
la trajectoire complète de la masse : pendant son élévation puis après l’interruption du lève-charge.
La session consiste en la réalisation individuelle d’une application informatique, depuis la
conception des algorithmes jusqu’à leur implémentation dans le langage Java.
1.2 Organisation de la session et rendu des travaux
Vous disposez de plus de 3 semaines pour la réalisation de ce projet, jalonnées comme suit :
pour le 14 mars lire l’énoncé du TP1 (section 2) ; organisez votre répertoire de travail (E1, sec-
tion 2.2) : seul le fichier PreTrajectoire.java ne sera disponible sur Campus qu’au début du
TP1.
14 mars première séance de TP – apportez votre polycopié PROGRAMMATION : conception,
implémentation et test des algorithmes ; code source à compléter PreTrajectoire.java ;
pour le 21 mars travail personnel requis : terminer PreTrajectoire.java ;
faire une copie nommée Trajectoire.java ; dans ce fichier, remplacer toutes les occurences de
PreTrajectoire par Trajectoire ; nettoyer la classe Trajectoire : supprimer les méthodes nom-
mées factorielle,sommeFactorielleNaif,sommeFactorielle,sommeExposant,ajouteSerie,
et leurs appels dans la méthode main ;
réfléchir à l’adaptation de la classe Trajectoire dans le cadre de la problématique du lève-charge ;
rassembler les paramètres nécessaires aux calculs.
21 mars seconde séance de TP NOTÉ – apportez votre polycopié PROGRAMMATION : procéder
à cette adaptation ; code source à modifier/compléter Trajectoire.java ;
21-31 mars fin de l’implémentation (+ améliorations facultatives proposées), validation et nettoyage
du code ;
31 mars – 20h date au plus tard de dépôt de l’archive complète du projet sur Campus.
Vous disposez jusqu’au 28 mars, sur Campus, d’un espace pour poser vos questions : Forum Questions
Informatique. Vous pouvez vous y abonner pour recevoir, par mail, les messages de ce forum :
https://nte.gemtech.fr/campus/mod/forum/view.php?id=10102
Les fichiers de code source devront être déposés sur Campus, dans l’espace intégrateur 1ère année.
Le retour des évaluateurs se fera aussi par l’intermédiaire de Campus. Prière de tenir compte de ces
commentaires...
EMN/CB1/integrateur/informatique2 -1- SD/2007-2008

1.3 Évaluation
La note de la partie informatique du projet intégrateur (2nde thématique transversale) comprend :
– l’évaluation des fichiers PreTrajectoire.java et Trajectoire.java, remis au TP2 (30%)
– l’évaluation de l’application finale (70%)
Ces évaluations reposeront principalement sur les critères suivants :
–respect des conditions de remise des devoirs : aucun devoir ne sera accepté au-delà des dates
et heures limites. Prenez vos précautions en cas de surcharge de Campus : n’attendez pas le dernier
moment et pensez à déposer une version préliminaire de votre projet quelque temps avant l’heure
limite.
–conformité du programme : tout programme rendu doit, a minima, compiler et s’exécuter. Les
parties de code développées en TP, non terminées ou qui ne compileraient pas à l’issue de la séance,
devront être placées en commentaire. L’application finale doit être validée par les tests.
–justesse de la programmation et des algorithmes : appel de méthodes, emploi des variables,
passage de paramètres, parcours de tableaux, emploi des boucles, etc.
–qualité (clarté) du code : les règles de programmation énoncées dans les cours de programmation
et d’algorithmique doivent être respectées.
Rappel : la fraude et la copie seront lourdement sanctionnées (=0, sans préjuger d’éventuelles
suites disciplinaires).
1.4 Groupes et enseignants
Répartition des élèves suivant les groupes APA : Philippe David (A), Sophie Demassey (B), Rémi
Douence (C), Jérôme Fortin (D), Assia Hachichi (E), Nicolas Loriant (F).
Resp : [email protected], bureau B210.
EMN/CB1/integrateur/informatique2 -2- SD/2007-2008

2 TP1 : conception et implémentation des algorithmes
2.1 Objectif et déroulement de la séance
Vendredi 14 mars 2008, 2h.
Avant de débuter le développement de l’application à proprement dite, vous concevrez et implémen-
terez, lors de cette séance, les différents algorithmes qui seront mis en œuvre et les testerez sur des
exemples de valeurs. Ces algorithmes consistent principalement en des calculs de sommes partielles et
d’expressions polynomiales sur des matrices. Le squelette de la classe PreTrajectoire, dans laquelle
vous implémenterez ces algorithmes, est fournie, ainsi qu’une classe Matrice, complète elle, qui fournit
l’ensemble des opérations requises pour la manipulation des matrices (création, somme, produit).
Comme les calculs à effectuer résultent parfois en de très grands nombres (supérieurs à 10300 ), cet
exercice vous donnera l’occasion d’observer un principe fondamental en informatique : l’infini n’existe
pas. En effet, comme l’espace mémoire d’un ordinateur est limitée, il n’est pas possible de manipuler
des données numériques arbitrairement grandes. Cependant, vous verrez que choisir un type de données
adéquate ou implémenter un algorithme intelligent permet de repousser cette limite.
Si vous souhaitez recevoir un commentaire sur votre code, vous avez la possibilité de déposer sur Campus
votre fichier PreTrajectoire.java à l’issue de la séance (avant 20h ce jour même). E0
2.2 Organisez votre répertoire de travail
Comme pour le projet précédent, votre application comprend plusieurs fichiers (code source, biblio-
thèques, fichier de configuration) ; aussi il est préférable d’organiser le répertoire la contenant :
1. créez le répertoire du projet th2_apa_X (remplacez Xpar votre nom), et ses trois sous-répertoires :
classes (pour les fichiers compilés .class), lib (pour les archives Java .jar) et src (pour les
fichiers source .java)
2. téléchargez depuis Campus (ou recopiez-les du projet 1) :
– les fichiers source PreTrajectoire.java et TraceSeries.java
– le fichier compilé Matrice.class
– les archives Java jfreechart.jar et jcommon.jar
et enregistrez-les dans les sous-répertoires correspondants.
3. compilez les fichiers sources et exécutez PreTrajectoire.
E1
Rappel des commandes sous Windows :
javac -d classes -cp classes;lib\jfreechart.jar;lib\jcommon.jar src\*.java compile
java -cp classes;lib\jfreechart.jar;lib\jcommon.jar PreTrajectoire exécute
Rappel des commandes sous Linux/MacOS :
mkdir rep crée le répertoire rep
javac -d classes -cp classes:lib/jfreechart.jar:lib/jcommon.jar src/*.java compile
java -cp classes:lib/jfreechart.jar:lib/jcommon.jar PreTrajectoire exécute
Rappel sur la signification des commandes :
– l’option -d rep stipule que les fichiers compilés seront placés dans le répertoire rep
– l’option -cp rep1;rep2;... indique les chemins d’accès aux bibliothèques (classpath)
– les noms des répertoires et archives Java contenant ces bibliothèques sont séparés par (;) sous
Windows ou (:) sous Linux
–*.java est une expression régulière signifiant « tous les fichiers dont le nom se termine par .java »
EMN/CB1/integrateur/informatique2 -3- SD/2007-2008

2.3 La classe PreTrajectoire
C’est dans cette classe, dont le squelette vous est fourni, que vous allez implémenter et tester les onze
algorithmes. À chaque algorithme correspond une unique méthode de la classe :
Partie 1 : séries, complexité, et problèmes numériques
int factorielle(int)
int sommeFactorielleNaif()
long sommeFactorielle()
double sommeExposant(double)
Matrice sommeExposant()
Matrice sommeExponentielle(double)
Partie 2 : calcul des fonctions matricielles
Matrice combinaisonMatrices(Matrice, Matrice, Matrice, Matrice, double)
Matrice Y(double)
Partie 3 : tracé des courbes
void ajouteSerie(TraceSeries)
void ajouteSerieTronquee(TraceSeries)
void traceCourbe()
Pour chaque méthode, vous trouverez dans le fichier PreTrajectoire.java : les spécifications de la
méthode (ce qu’elle fait et comment elle s’utilise), la signature de la méthode et le bloc avec, éventuelle-
ment, une instruction de retour à remplacer1, par exemple :
/**
*calcul de la factorielle de jfonction
* @param j entier positif noms et types des paramètres en entrée
* @return 1x2x..xj entier valeur et type de la donnée de retour
*/
public int factorielle(int j) {
return 1 ; instruction à modifier
}
La procédure de test de vos algorithmes est détaillée dans la méthode main. Il s’agit de vérifier (par
simple affichage) que chaque méthode retourne bien la valeur attendue sur des exemples de valeurs d’en-
trées donnés. Des questions concernant la complexité des algorithmes sont aussi posées. Vous pouvez y
répondre par un commentaire dans le code. Par exemple :
public static void main (String[] args) {
PreTrajectoire T = new PreTrajectoire() ;
// Q1 : implementer factorielle(int)
// verifier : T.factorielle(0) == 1
System.out.println("facto(0) : " + T.factorielle(0)) ;
// combien d’operations sont effectuees par la methode factorielle(10) ?
// REPONSE : 9
}
1les instructions de retour sont nécessaires à rendre le fichier compilable en l’état
EMN/CB1/integrateur/informatique2 -4- SD/2007-2008

Compléter PreTrajectoire.java, en suivant les instructions détaillées dans la méthode main :
Q1 : implementer : factorielle(int)
verifier : T.factorielle(0) == 1
verifier : T.factorielle(10) == 3628800
combien d’operations (multiplication d’entiers) sont effectuees par la methode factorielle(10) ?
combien d’operations (multiplication d’entiers) sont effectuees par la methode factorielle(j), j>1 ?
Q2 : implementer : sommeFactorielleNaif()
(T.I=10) verifier : T.sommeFactorielleNaif() == 4037914
combien d’operations (somme et multiplication d’entiers) sont effectuees par sommeFactorielleNaif() ?
Q3 : implementer : sommeFactorielle()
(T.I=10) verifier : T.sommeFactorielle() == 4037914
combien d’operations (somme et multiplication d’entiers) sont effectuees par sommeFactorielle() ?
poser I=100 dans le constructeur PreTrajectoire()
verifier : T.sommeFactorielle() == 1005876315485501978
expliquer pourquoi T.sommeFactorielleNaif() ne retourne pas ce resultat ?
facultatif : effectuer les modifications necessaires
Q4 : implementer : sommeExposant(double)
(T.I=100) verifier : T.sommeExposant(0) == 1
verifier : T.sommeExposant(1) == 101
verifier : T.sommeExposant(2) == 2.5353012004564588E30 > 2.1030
verifier : T.sommeExposant(10) == 1.1111111111111118E100 > 1.10100, expliquer ce chiffre 8 ?
calculer : T.sommeExposant(10000), interpreter
poser I=500 dans le constructeur PreTrajectoire()
noter que sommeExposant(10) n’est plus calculable ainsi
Q5 : implementer : sommeExposant()
(T.I=500, T.M={{1,0,0},{0,1,0},{0,0,1}}, la matrice identite de taille 3 : Id3)
verifier : T.sommeExposant() == 501.Id3
poser M={{0,1,0},{-50,0,50},{0,0,0}} dans initialiseMatrices()
calculer T.sommeExposant(), interpreter
poser M={{0,1,0},{0,0,0},{0,0,0}} dans initialiseMatrices()
verifier : T.sommeExposant() == Id3+M == {{1,1,0},{0,1,0},{0,0,1}}
Q6 : implementer : sommeExponentielle(double)
(T.I=500, T.M={{0,1,0},{0,0,0},{0,0,0}})
verifier : T.sommeExponentielle(0) == Id3
verifier : T.sommeExponentielle(2) == Id3 + 2.M
poser M=Id3 dans initialiseMatrices()
verifier : T.sommeExponentielle(0) == Id3
verifier : T.sommeExponentielle(2) == (7.389056098930649).Id3
Q7 : implementer : combinaisonMatrices(Matrice,Matrice,Matrice,Matrice,double)
declarer et initialiser une matrice 3x3 : B = Id3
declarer et initialiser une matrice 3x1 : C = {{1},{1},{1}}
verifier : T.combinaisonMatrices(B,C,C,C,2) == 4.C
verifier : T.combinaisonMatrices(B,C,C,C,0) == 2.C
Q8 : implementer : Y(double)
(T.I=500, T.M=Id3) verifier : T.Y(0) == combinaisonMatrices(B,C,C,C,0) == 2.C
verifier : T.Y(2) == (10.389056098930649).C
Q9 : implementer : ajouteSerie(TraceSeries) et traceCourbe()
afficher la courbe x(t)
Q10 : implementer : ajouteSerieTronquee(TraceSeries)
modifier traceCourbe() pour afficher la courbe tronquee
faire afficher tBarriere par ajouteSerieTronquee(TraceSeries)
modifier x(double) de sorte que x(t) == le premier element du vecteur Y(t) pour tout t
poser I=100, XBarriere=4.5, M={{0,1,0},{-50,0,50},{0,0,0}}
E2
EMN/CB1/integrateur/informatique2 -5- SD/2007-2008