Méthodes Numériques et Informatiques Examen du 5 janvier 2010 I

Université Paris vi : M1 Master de Sciences et Technologies
Mentions physique et applications et SDUEE
2009-2010
MP050
Méthodes Numériques et Informatiques
Examen du 5 janvier 2010
Calculatrices et documents autorisés
Durée 2 heures 30.
Les trois parties sont indépendantes.
Les questions indépendantes sont signalées par le symbole ?
Dans toutes les réponses exprimées en unix, indiquer explicitement tous les blancs par le symbole ␣
Traiter les questions de programmation
en choisissant soit le Fortran, soit le langage C
et l’indiquer sur votre copie.
I
Unix
Vous êtes l’utilisateur user1 du groupe enseignants. Dans votre répertoire d’accueil /home/user1/, vous disposez
d’un sous-répertoire /home/user1/paris/ecoles/, contenant les notes des élèves des écoles primaires de la ville de
Paris. Les résultats de chaque école sont contenus dans un fichier dont le nom est du type : res_XX_YY.dat,
où XX désigne le numéro de l’arrondissement (entre 01 et 20) et YY le numéro de l’école (supérieur ou égal à 01) dans
l’arrondissement.
Exemple de fichier pour la première école
Chaque fichier comprend les résultats d’une école toutes
du 5e arrondissement
classes confondues, chaque ligne du fichier indiquant les
fichier res_05_01.dat :
résultats d’un élève, sous la forme de huit colonnes :
colonne 1 : le nom de l’élève,
Torino
Abracpova
Etter
Alonso
Badertscher
Beaumier
Blatter
Bonacci
Barry
Carpinteiro
Comino
Doutre
Banesic
Dejoux
colonne 2 : son prénom,
colonne 3 : sa classe (cp, ce1, ce2, cm1 ou cm2),
colonne 4 : sa moyenne en Français,
colonne 5 : sa moyenne en Histoire,
colonne 6 : sa moyenne en Géographie,
colonne 7 : sa moyenne en Mathématiques,
Stefy
Olga
Aurelia
Christina
Valentine
Marie
Isabelle
Helene
Irene
Vanessa
Daniela
Delphine
Silvia
Laure
cm1
ce1
cm2
cp
cm2
cp
ce1
ce2
cm1
cm1
ce2
cp
cp
cm1
8
5
6
9
8
5
6
9
4
6
4
5
7
4
5
8
6
9
7
6
3
7
5
8
9
5
9
2
6
9
9
8
5
7
6
5
4
9
7
4
8
8
colonne 8 : sa moyenne en Sciences naturelles.
Dans ces fichiers, les noms et prénoms ne comportent pas d’espace et les notes sont des entiers entre 0 et 9.
Votre répertoire de travail est /home/user1/.
4
8
4
6
4
8
2
8
8
6
5
7
8
9
7
5
9
7
9
4
9
7
5
8
5
8
8
8
? Q 1 : Indiquer la commande pour construire un répertoire stats/ sous le répertoire paris/.
? Q 2 : Quelle commande permet d’afficher le nombre d’écoles primaires à Paris ?
? Q 3 : Indiquer la commande qui permet d’afficher les noms et attributs de tous les fichiers du répertoire paris/
tel qu’indiqué ci-dessous ?
drwxr-xr-x 4 user1 enseignants
drwxr-xr-x 12 user1 enseignants
drwxr-x--- 15 user1 enseignants
drwxrwxr-x 16 user1 enseignants
1024
1024
4096
1024
Dec
Dec
Dec
Dec
22
22
24
25
15:29
15:29
00:00
12:00
./
../
ecoles/
stats/
? Q 4 : Quelle(s) commande(s) permet(tent) de donner au répertoire stats/ les mêmes droits que ceux du répertoire
ecoles/ ?
? Q 5 : Quelle commande permet de faire du répertoire stats/ votre répertoire de travail ?
Dans les questions suivantes, on suppose que stats/ reste votre répertoire de travail.
1/8
Université Paris vi : M1 Master de Sciences et Technologies
Mentions physique et applications et SDUEE
2009-2010
MP050
? Q 6 : On souhaite travailler sur les résultats de l’ensemble des écoles du 5e arrondissement. Copier les fichiers de
résultats nécessaires dans votre répertoire courant.
? Q 7 : Concaténer les fichiers copiés en un seul fichier stats_05.dat.
Dans les questions suivantes sauf la dernière (Q 13), on utilisera le fichier stats_05.dat.
? Q 8 : Quelle commande permet d’afficher le nombre total d’élèves du 5e arrondissement ?
? Q 9 : Créer les trois fichiers stats_05_cp.dat, stats_05_ce.dat, stats_05_cm.dat contenant respectivement les
résultats des classes de CP, puis de CE1 et CE2 (confondus), puis de CM1 et CM2 (confondus).
? Q 10 : Pour chaque élève de CM, quelle commande permet d’afficher une neuvième colonne correspondant à sa
moyenne générale (toutes les disciplines ont le même coefficient) ?
? Q 11 : Afficher les informations des 3 élèves de CE ayant eu les meilleures notes en Mathématiques.
? Q 12 : Quelle commande permet de calculer la moyenne en Sciences naturelles des élèves de CM ?
? Q 13 : En gardant stats/ comme répertoire de travail, quelle commande permet d’obtenir le nombre d’élèves de
CE2, sur l’ensemble de la ville, ayant obtenu 9 en Géographie ?
II
Exercice
On s’intéresse à des données de précipitations totales journalières échantillonnées sur une grille rectangulaire de
nlat points en latitude par nlon points en longitude : chaque valeur de précipitation représente la moyenne des
précipitations sur la maille élémentaire 1 de la grille. Les données de précipitations constituent une matrice stockée
sous forme de tableau 2D de réels nommé mat de taille nlat par nlon et alloué par le programme principal. En
fortran comme en C, le premier indice décrit les latitudes et le second décrit les longitudes. D’autre part, les tableaux
1D x et y fournissent les nlon valeurs réelles des longitudes et les nlat valeurs réelles des latitudes de la grille utilisée.
II.A
Procédures à écrire
Dans toutes les questions de cette section, les procédures demandées doivent respecter un prototype permettant de les
appeler comme mentionné dans le programme principal fourni en annexe IV.A.1, page 5. En fortran, on précisera les
attributs INTENT des arguments des procédures.
? Q 14 : Écrire une fonction moyenne qui calcule et renvoie la valeur moyenne des précipitations sur toute la grille
mat (voir l’appel dans le programme principal ligne 71 en fortran et ligne 69 en C).
? Q 15 : Écrire une procédure compte_zeros qui compte, pour chaque bande de latitude, le nombre de mailles
(aux différentes longitudes) où les précipitations sont négligeables (en pratique inférieures à 0.001). Cette procédure
remplira un tableau 1D nommé nb_zeros de taille nlat préalablement alloué par le programme principal (voir l’appel
dans le programme principal ligne 76 en fortran et ligne 74 en C).
? Q 16 : On souhaite dégrader la résolution spatiale des données d’un facteur 2 dans les deux directions ce qui
multiplie par 4 la surface de la maille élémentaire (voir fig. 1). Les précipitations sur le domaine sont alors décrites
par une grille matr comportant 2 fois moins d’éléments dans chaque direction. La valeur de précipitation dans la
maille grossière est la moyenne des valeurs des quatre mailles fines qui la constituent. Écrire une procédure nommée
regrille qui effectue ce re-échantillonage en remplissant le tableau 2D basse résolution à partir des valeurs de la
grille initiale (voir l’appel dans le programme principal ligne 80 en fortran et ligne 78 en C). On suppose que les
nombres de longitudes et de latitudes de la grille initiale sont tous les deux pairs. On rappelle qu’en fortran, les
indices des tableaux commencent à 1...
1. On suppose que la surface de la maille est constante en particulier indépendante de la latitude.
2/8
Université Paris vi : M1 Master de Sciences et Technologies
Mentions physique et applications et SDUEE
2009-2010
MP050
nlat
nlon
Figure 1 – Dégradation de la résolution spatiale : exemple du passage d’une grille 4 × 6 à une grille 2 × 3
II.B
Codes fournis à expliquer
? Q 17 : Dans le programme principal (voir IV.A.2, page 6), quel est le rôle de la boucle while de la ligne 103 en
fortran, et de la ligne 103 en C ? Proposer un texte plus informatif pour remplacer le message de la ligne 107 en
fortran et de la ligne 107 en C.
? Q 18 : Expliquer le rôle des lignes de code numérotées de 112 à 123 en fortran et de 112 à 123 en C (voir IV.A.2,
page 6).
Q 19 : Décrire avec précision le rôle des lignes de code numérotées de 126 à 139 en fortran et de 126 à 139 en C
(voir IV.A.2, page 6). Expliquer quelles sont les valeurs de qlat et qlon à la fin de ce code.
III
Problème
Les procédures demandées dans cette partie doivent respecter les prototypes incomplets indiqués dans l’annexe IV.B
qui comporte aussi les codes fournis pour cette partie. En fortran, on précisera les attributs INTENT des arguments des
procédures.
III.A
Recherche de zéro par la méthode de Newton (voir prototypes incomplets en
annexe IV.B.1, page 7)
Principe
La méthode de Newton permet de rechercher, par approximations successives, les
solutions d’équations du type f (x) = 0,
lorsque la dérivée f 0 de la fonction f est
connue. On choisit tout d’abord une première approximation x0 de la solution
dans le domaine de définition de f . Puis,
on itère le processus suivant : si xn est
l’approximation de la solution à l’étape n
de l’algorithme, l’approximation suivante
xn+1 est obtenue en calculant l’intersection de la tangente à f en xn avec l’axe
des abscisses (voir la figure ci-contre).
Figure 2 – Méthode de Newton : x1 est l’intersection avec l’axe des abscisses de la tangente
à f en x0 . Puis x2 est construit à partir de la
tangente en x1 , et ainsi de suite.
? Q 20 : Dans le cas général, écrire l’équation de la tangente à f en un point d’abscisse xn , en fonction de xn , f (xn )
et f 0 (xn ). En déduire xn+1 en fonction de xn , f (xn ) et f 0 (xn ).
3/8
Université Paris vi : M1 Master de Sciences et Technologies
Mentions physique et applications et SDUEE
On considère dans cette partie la fonction
f (x) = ln x + x.
? Q 21 : Faire une étude succincte de cette
fonction : préciser en particulier son domaine
de définition, sa dérivée, son sens de variation,
ses limites aux bornes du domaine de définition. La courbe représentative de la fonction f
est fournie figure 3. Proposer un encadrement
de la solution de l’équation f (x) = 0.
Q 22 : On choisit x0 = 1. Calculer à la main
x1 par la méthode de Newton. Vérifier graphiquement sur la figure 3.
2009-2010
MP050
5
log(x)+x
4
3
2
Figure 3 – Tracé de la
fonction ln(x) + x
1
0
? Q 23 : Écrire en C ou en Fortran une fonction nommée f qui admet un argument réel x,
et calcule f (x).
-1
Q 24 : Écrire de même une fonction fp qui
calcule f 0 (x).
-2
-3
0
1
2
3
4
Q 25 : Écrire une fonction newton qui admet un argument xn et permet d’avancer d’une seule étape dans
l’algorithme de Newton. Cette fonction calcule donc xn+1 à partir de xn en faisant appel à f et fp.
Q 26 : Écrire le programme principal qui demande à l’utilisateur de saisir x0 , effectue 10 itérations de l’algorithme
de Newton, et affiche les approximations successives de la solution à l’équation f (x) = 0.
III.B
Polynômes (voir interfaces incomplètes en annexe IV.B.2)
Informatiquement, un polynôme est représenté par un vecteur contenant l’ensemble de ses coefficients. Ainsi, pour le
polynôme de degré n, a0 + a1 X + . . . + an X n (où an 6= 0), on stocke le tableau 1D de taille n + 1 (a0 , a1 , . . . , an ).
Le programme principal portant sur la partie III.B sera rendu sur une feuille séparée et construit au fur et à mesure des
questions de cette partie. En C, on pourra utiliser les tableaux automatiques à déclaration tardive.
? Q 27 : Écrire un nouveau programme principal qui demande à l’utilisateur de saisir le degré du polynôme et effectue
l’allocation d’un tableau nommé poly permettant de stocker ses coefficients. La taille du tableau devra être définie
en fonction du degré choisi par l’utilisateur.
? Q 28 : On fournit la procédure saisie_pol qui demande à l’utilisateur de saisir les différents coefficients du
polynôme et qui remplit le tableau passé en argument (voir IV.B.2.1, page 7 en C et IV.B.2.2, page 8 en fortran).
Compléter le programme principal pour appeler cette procédure.
? Q 29 : Quelles sont les expressions analytiques calculées par chacune des fonctions expr1 et expr2 fournies en
annexe (voir IV.B.2.1, page 7 en C et IV.B.2.2, page 8 en fortran) ? Dans chaque cas, préciser les expressions
développées pour un polynôme de degré 3. Compter le nombre de multiplications effectuées par chacune de ces
fonctions : en déduire la méthode la plus efficace. On comptablisera les appels à la fonction pow() en C ou à
l’opérateur ** en Fortran comme autant de multiplications implicites associées.
? Q 30 : Écrire une procédure deriv qui remplit le vecteur associé au polynôme dérivé d’un polynôme passé en
argument. L’allocation du tableau pour le polynôme dérivé sera faite dans le programme principal. Compléter le
programme principal pour appeler cette procédure.
Q 31 : Écrire une fonction newton_poly permettant d’avancer d’une seule étape dans l’algorithme de Newton
lorsque l’on recherche le zéro d’un polynôme.
4/8
Université Paris vi : M1 Master de Sciences et Technologies
Mentions physique et applications et SDUEE
IV
51
52
53
54
Annexes
IV.A
Annexes de l’exercice (voir II)
IV.A.1
Partie de code fourni à titre indicatif (voir II.A)
int main(void){
FILE *fid;
int i, j, nlat, nlon, plat, plon, qlat, qlon;
float moy,lon_min,lon_max,lat_min,lat_max;
55
56
57
58
59
60
61
62
63
64
65
/*Lecture de la matrice*/
fid=fopen("data.txt","r");
fscanf(fid, "%d %d", &nlat, &nlon);
float mat[nlat][nlon]; // tableau automatique
for (i=0; i < nlat; i++) {
for (j=0; j < nlon; j++) {
fscanf(fid, "%g", &mat[i][j]);
}
}
fclose(fid);
program principal
use precipitation
implicit none
integer :: i, j, nlat, nlon, plat, plon, qlat, qlon
real :: moy, lon_min, lon_max, lat_min, lat_max
integer, dimension(:), allocatable :: nb_zeros
real, dimension(:), allocatable :: x, y
real, dimension(:,:), allocatable:: mat, matr, matz
67
69
70
/* Moyenne */
moy = moyenne(nlat, nlon, mat); //
printf("Moyenne %g\n",moy);
73
74
/* Nombre de zeros par latitude*/
int nb_zeros[nlat];
compte_zeros(nlat, nlon, mat, nb_zeros); //
77
78
/* Regrillage */
float matr[nlat/2][nlon/2]; // tableau automatique
regrille(nlat, nlon, mat, matr); //
81
82
83
84
85
86
87
88
89
90
91
92
54
55
56
57
58
60
61
62
63
64
65
66
67
68
70
71
72
74
75
76
77
! Regrillage
allocate(matr(nlat/2, nlon/2))
call regrille(mat, matr) !
79
80
53
73
! Nombre de zeros par latitude
allocate(nb_zeros(nlat))
call compte_zeros(mat, nb_zeros) !
75
76
52
69
! Moyenne
moy = moyenne(mat) !
write(*,*) "moyenne", moy
71
72
51
59
! Lecture de la matrice
open(unit=11,file="data.txt", &
form="formatted",status="old")
read(11,*) nlat, nlon
allocate(mat(nlat, nlon))
do i=1,nlat
read(11,*) mat(i,:)
enddo
close(11)
66
68
2009-2010
MP050
/* Axes */
float x[nlon]; // tableau automatique
float y[nlat]; // tableau automatique
fid=fopen("axe_x.txt","r");
for (i=0; i < nlon; i++) {
fscanf(fid, "%f", &x[i]);
}
fclose(fid);
fid=fopen("axe_y.txt","r");
for (i=0; i < nlat; i++) {
fscanf(fid, "%g", &y[i]);
}
fclose(fid);
78
79
80
81
! Axes
allocate(x(nlon))
allocate(y(nlat))
open(unit=11, file="axe_x.txt", &
form="formatted",status="old")
read(11,*) x(:)
close(11)
open(unit=11, file="axe_y.txt", &
form="formatted",status="old")
read(11,*) y(:)
close(11)
5/8
82
83
84
85
86
87
88
89
90
91
92
Université Paris vi : M1 Master de Sciences et Technologies
Mentions physique et applications et SDUEE
IV.A.2
94
95
96
97
2009-2010
MP050
Partie de code à commenter (voir II.B)
printf("Longitude min: %g\n Longitude max: %g\n"
"Latitude min: %g\n Latitude max:%g\n",
x[0], x[nlon-1],
y[0], y[nlat-1]);
write(*,*) "Longitude min:",
"Longitude max:",
"Latitude min:",
"Latitude max:",
x(1),
&
x(nlon), &
y(1),
&
y(nlat)
printf("Sélection de zone:\n"
"Indiquer lon_min, lon_max, lat_min, lat_max\n");
scanf("%g %g %g %g",
&lon_min, &lon_max, &lat_min, &lat_max);
while ( lon_min < x[0]
||
//
lon_max > x[nlon-1] ||
lat_min < y[0]
||
lat_max > y[nlat-1] ){
printf("Message a modifier\n"); //
scanf("%g %g %g %g",
&lon_min, &lon_max, &lat_min, &lat_max);
}
write(*,*) "Sélection de zone:"
99
write(*,*) "Indiquer lon_min,lon_max,lat_min,lat_max" 100
read (*,*) lon_min, lon_max, lat_min, lat_max
101
plon=0; //
for (i=0; i < nlon; i++)
if ((x[i]>=lon_min) &&
plon++;
}
}
plat = 0;
for (i=0; i < nlat; i++)
if ((y[i]>=lat_min) &&
plat++;
}
}
//
plon = 0 !
do i=1, nlon
if ((x(i)>=lon_min) .AND. (x(i)<=lon_max)) then
plon = plon + 1
end if
end do
plat = 0
do i=1, nlat
if ((y(i)>=lat_min) .AND. (y(i)<=lat_max)) then
plat = plat + 1
end if
end do !
98
99
100
101
102
103
104
105
106
107
108
109
110
113
114
115
116
117
118
119
120
121
122
123
126
127
128
129
130
131
132
133
134
135
136
137
138
139
142
97
lon_min < x(1)
) .OR. & !
lon_max > x(nlon) ) .OR. &
lat_min < y(1)
) .OR. &
lat_max > y(nlat) )
)
"Message a modifier" !
lon_min, lon_max, lat_min, lat_max
103
104
105
106
107
108
109
110
111
{
(x[i]<=lon_max)){
{
(y[i]<=lat_max)){
112
113
114
115
116
117
118
119
120
121
122
123
124
// tableau automatique
float matz[plat][plon]; //
qlat = 0;
for (i=0; i < nlat; i++) {
if ((y[i]>=lat_min) && (y[i]<=lat_max)){
qlon = 0;
for (j=0; j < nlon; j++) {
if ((x[j]>=lon_min) && (x[j]<=lon_max)){
matz[qlat][qlon] = mat[i][j];
qlon++;
}
}
qlat++;
}
} //
140
141
96
102
do while ( (
(
(
(
write(*,*)
read (*,*)
end do
124
125
95
98
111
112
94
exit(EXIT_SUCCESS);
}
125
allocate(matz(plat, plon)) !
126
qlat = 1
127
do i=1, nlat
128
if ((y(i)>=lat_min) .AND. (y(i)<=lat_max)) then
129
qlon = 1
130
do j=1, nlon
131
if ((x(j)>=lon_min) .AND. (x(j)<=lon_max)) then 132
matz(qlat, qlon) = mat(i, j)
133
qlon = qlon + 1
134
end if
135
end do
136
qlat = qlat + 1
137
end if
138
end do !
139
deallocate(mat, nb_zeros, matr)
140
deallocate(matz, x, y)
141
end program principal
142
6/8
Université Paris vi : M1 Master de Sciences et Technologies
Mentions physique et applications et SDUEE
2009-2010
MP050
IV.B
Annexes du problème (voir III)
IV.B.1
Prototypes incomplets pour la méthode de Newton (voir III.A)
IV.B.1.1
Langage C
IV.B.1.2
Fonction f
Fonction f
f(
x) ;
function f(x)
Fonction fp
Fonction fp
fp(
x) ;
function fp(x)
Fonction newton
Fonction newton
newton(
IV.B.2
IV.B.2.1
Langage Fortran
xn) ;
function newton(xn)
Codes et prototypes à compléter pour les polynômes (voir III.B)
Langage C
Fonction saisie_pol
void saisie_pol(const int d, float poly[d+1]) {
for (int i=0; i<=d; i++) {
printf("coeff du monome de degre %d ?\n", i);
scanf("%g", &poly[i]);
}
return;
}
Fonctions expr1 et expr2
1
2
float expr1(const int d, const float poly[d+1], const float x) {
float res;
3
res = poly[0];
for (int i=1; i<=d; i++) {
res += poly[i] * pow(x,i);
}
return res;
4
5
6
7
8
9
}
10
11
12
float expr2(const int d, const float poly[d+1], const float x) {
float res;
13
14
15
16
17
18
res = poly[d];
for (int i=d; i>0; i--) {
res = res * x + poly[i-1];
}
return res;
Fonction deriv
deriv(
d,
poly[
],
dpoly[
7/8
]);
Université Paris vi : M1 Master de Sciences et Technologies
Mentions physique et applications et SDUEE
2009-2010
MP050
Fonction newton_poly
newton_poly(
IV.B.2.2
xn,
d,
poly[
],
Langage Fortran
Sous-programme saisie_pol
subroutine saisie_pol(poly)
implicit none
real, intent(out), dimension(:) :: poly
integer :: i
do i=1, size(poly)
write (*,*) "coeff du monome de degre", i-1, "?"
read (*,*) poly(i)
enddo
end subroutine saisie_pol
Fonctions expr1 et expr2
1
2
3
real function expr1(poly, x)
real, intent(in), dimension(:) :: poly
real, intent(in) :: x
4
5
integer :: i
6
7
8
9
10
11
expr1 = poly(1)
do i=2, size(poly)
expr1 = expr1 + poly(i) * x**(i-1)
enddo
end function expr1
12
13
14
15
real function expr2(poly, x)
real, intent(in), dimension(:) :: poly
real, intent(in) :: x
16
17
integer :: i, d
18
19
20
21
22
23
24
d = size(poly) - 1
expr2 = poly(d+1)
do i=d, 1, -1
expr2 = expr2 * x + poly(i)
enddo
end function expr2
Sous-programme deriv
subroutine
deriv(poly, dpoly)
Fonction newton_poly
function newton_poly(xn, poly, dpoly)
8/8
dpoly[
]);