Examen 04 03 08 Avec Corrige

Numéro d’anonymat : 1 2008-03-05 01 :24 :46.
000000000
Reportez votre numéro d’anonymat dans le cadre ci-dessous et en haut à gauche de chaque page de
l’énoncé.
A la fin de l’épreuve glissez ce cahier dans la copie double qui vous a été fournie, qui comporte
votre numéro d’anonymat et sur laquelle vous aurez écrit et masqué votre nom en rabattant dessus
et en collant la languette triangulaire. Vous ne devez rien écrire d’autre sur cette copie double.
Numéro d’anonymat :
UNIVERSITE DE PARIS SUD Centre d’Orsay 2007-2008 première session d’examen
L3 et Magistère 1ère année de Physique fondamentale
Examen d’informatique Mardi 4 Mars 2008 14h à 16h bât. 337
Aucun document n’est autorisé.

Les programmes doivent être écrits en C/C++. Les réponses doivent obligatoirement être écrites sur les feuilles
de l’énoncé, dans l’espace réservé. Il est fortement conseillé de rédiger d’abord le plan des réponses au brouillon.
Respecter les notations de l’énoncé.
Ne pas commencer à répondre à un exercice avant de l’avoir entièrement lu.
L’utilisation de fonctions est laissée à l’appréciation de l’étudiant, sauf quelques cas où elle est imposée.
On suppose que tous les #include<stdlib.h> ... using namespace std ; #include<bibli fonctions.h> nécessaires
sont sous-entendus, il n’y a pas à les écrire.
On rappelle qu’on ouvre un fichier en écriture par l’instruction : fstream xxx("nom de fichier.qqc",ios : :out) ;
et en lecture par : fstream yyy("nom de fichier.qqc",ios : :in) ;
Ne pas faire lire les données au clavier ou dans un fichier par un cin >>, ou l’équivalent pour un fichier, sauf si
cela est explicitement demandé. Par défaut, les données seront donc fournies dans le programme lui-même, par
des instructions du type :
dx=0.01;
a=1.7; b=1.1;
etc.
Dans chaque exercice on suppose que le programme principal1 et les fonctions2 sont écrits dans un unique fichier.
Les exercices sont indépendants les uns des autres.
Le nombre d’étoiles (de zéro à trois) donne une indication sur le niveau de l’exercice.
Le nombre de points (sur 40) attribué à chaque exercice est indiqué entre parenthèses après le nom de l’exercice
(c’est un barème indicatif ). Deux points sont réservés à la qualité de la présentation.
A titre indicatif le nombre de lignes du corrigé de chaque exercice est indiqué entre crochets (tout compris, c’est
à dire avec int main(), les accolades, return 0 ;, des commentaires éventuels).
Le corrigé pourra être consulté sur le site du cours.
1 s’il y en a un
2 s’il y en a
Licence et Magistère 1ère année de Physique fondamentale Examen d’informatique 2007-2008 première session
Numéro d’anonymat : 2 2008-03-05 01 :24 :46.000000000
Vecteurs perpendiculaires * (2) [12 lignes]

π
On considère, dans le plan, un vecteur −
→
x et le vecteur −
→
y de même module que −
→
x et faisant avec lui un angle . Si
−
→ 2
x a pour composantes x et x , −
0
→y a pour composantes y = −x et y = x .
1 0 1 1 0
Question 1 : écrire une fonction à laquelle on fournit un tableau contenant x0 et x1 et qui retourne un tableau
contenant y0 et y1 .
Question 2 : écrire l’appel de la fonction par le programme principal.
Réponse :
#define N 2
//-----------------------------------------------------------------------------------------------------
void perp(double *x,double *y)
{
y[0]=-x[1]; y[1]=x[0];
}
//-----------------------------------------------------------------------------------------------------
int main()
{
double x[N]={1,2},y[N];
perp(x,y);
cout << x[0] << " " << x[1] << " " << y[0] << " " << y[1] << endl;
return 0;
}
//-----------------------------------------------------------------------------------------------------
Résultats * (2) [3 lignes]

Question 1 : quels sont les résultats affichés à l’écran par les deux programmes suivants ?
double f(double x) double f(double x)
{ {
return 1/(1+x*x) ; return 1/(1+x*x) ;
} }
double g(double x) double g(double x,double (*h)(double))
{ {
return f(x)+1/f(x) ; return h(x)+1/h(x) ;
} }
int main() int main()
{ {
double x=1 ; double x=1 ;
cout << g(x) << endl ; cout << g(x,f) << endl ;
return 0 ; return 0 ;
} }
Réponse : Réponse :
2.5 2.5
Question 2 : en quoi ces deux programmes diffèrent-ils ?
Réponse :
Dans le programme de gauche la fonction g ne peut utiliser que la fonction f.
Dans celui de droite la fonction g peut utiliser tout fonction de type double ...(double).
Probabilité * (7) [17 lignes]

On lance deux pièces de même rayon r dans une boı̂te carrée de côté 1. Les pièces ne peuvent déborder de la boı̂te.
Question : écrire un programme calculant par une méthode statistique la probabilité pour que les deux pièces se
1
chevauchent, ceci pour n valeurs de r régulièrement réparties entre 0 et .
2
Réponse :
//-----------------------------------------------------------------------------------------------------
int main()
{
int i,j,nt=10000,n,np=100; double r,a,d2,dia2,x1,y1,x2,y2;
for(j=0;j<np;j++)
{
r=j/2./(np-1);
a=1-2*r; dia2=4*r*r;
for(n=0,i=1;i<=nt;i++)
{
x1=a*alea()+r; y1=a*alea()+r; x2=a*alea()+r; y2=a*alea()+r;
d2=(x2-x1)*(x2-x1)+(y2-y1)*(y2-y1);
if(d2<=dia2) n++;
}
cout << r << " " << (double)n/nt << endl;
}
return 0;
}
//-----------------------------------------------------------------------------------------------------
Commentaire :
On obtient la courbe
1
0.8
0.6
0.4
0.2
0
0 0.1 0.2 0.3 0.4 0.5
r
Fig. 1 – Probabilité de chevauchement en fonction de r
1
La probabilité vaut 1 pour r ≥ √ √ (abscisse de la droite verticale).
2(1 + 2)
Intersection d’intervalles ** (6) [17 lignes]

On considère un ensemble de N intervalles de l’axe des réels [ai , bi ], i = 0, ..., N − 1.
Soit α le plus grand des ai et β le plus petit des bi . Si α > β les intervalles [ai , bi ] ont une intersection vide. Sinon
leur intersection est l’intervalle [α, β].
Question 1 : écrire une fonction qui vaut :
1 si l’intersection des intervalles n’est pas vide, et renvoie dans ce cas les bornes de l’intervalle intersection
0 sinon
Les intervalles [ai , bi ] sont fournis à la fonction par l’intermédiaire de deux tableaux à un indice et N éléments,
nommés a et b.
Question 2 : Ecrire l’appel de la fonction par le programme principal.
Réponse :
#define N 5
//-----------------------------------------------------------------------------------------------------
int inter(double *xi,double *xs,double *inf,double *sup,int n)
{
int i;
*inf=xi[0]; *sup=xs[0];
for(i=1;i<n;i++) {if(xi[i]>*inf) *inf=xi[i]; if(xs[i]<*sup) *sup=xs[i];}
if(*inf>*sup) return 0; else return 1;
}
//-----------------------------------------------------------------------------------------------------
int main()
{
double a[N]={1.5,-1.8,2.4,2.7,0.5},b[N]={2.9,3.5,4.3,6.7,6.3},min,max;
if(inter(a,b,&min,&max,N)==0)
cout << "Intervalle vide" << endl;
else
cout << min << " " << max << endl;
return 0;
}
//-----------------------------------------------------------------------------------------------------
Frottement solide ** (7) [16 lignes]

Une particule de masse m se déplaçant sur un axe horizontal est lancée à partir d’une position x0 avec une vitesse
initiale v0 . La seule force à considérer est une force de frottement solide de module constant, opposée à la vitesse et
nulle quand la vitesse est nulle, donc de la forme
v
−k quand v 6= 0 et 0 quand v = 0
|v|
k étant une constante et v la vitesse de la particule.
Question : écrire un programme le plus rudimentaire et court possible, sans utiliser ni tableau ni fonction, pour
calculer, par la méthode d’Euler, la position de la particule à n instants répartis régulièrement de 0 à T . On choisit
m = 1, k = 10, x0 = 0, v0 = 10, T = 2 en unités SI. Ecrire le résultat dans un fichier nommé frottement.res en
mettant un couple temps-position par ligne.
Réponse :
//-----------------------------------------------------------------------------------------------------
int main()
{
int i,np; double x,v,t,dt,tfin,m,k;
fstream res("frottement.res",ios::out);
m=1; k=10; np=10000; tfin=2; dt=tfin/(np-1);
t=0; x=0; v=10;
for(i=1;i<=np;i++)
{
res << t << " " << x << endl;
x+=v*dt;
if(v!=0.) v+=-k/m*v/fabs(v)*dt;
t=t+dt;
}
res.close();
return 0;
}
//-----------------------------------------------------------------------------------------------------
Commentaire :
On obtient la courbe
6
3
x
0
0 0.5 1 1.5 2
t
Fig. 2 – Position de la masse en fonction du temps
La masse s’arrête en une seconde.
Histogramme d’une image ** (8) [37 lignes]

Une photographie numérique en noir et blanc est constituée de points, nommés pixels, chacun de ces points se
situant dans une gamme de gris allant du blanc au noir. Le fichier contenant cette photographie, supposé nommé
volcan 1.pgm, peut se présenter sous la forme très simple suivante (format pgm) :
512 346
255
76
37
49
...
Les deux nombres entiers de la première ligne sont le nombre de pixels en horizontal et le nombre de pixels en vertical.
Dans cet exemple l’image a donc 512 × 346 pixels.
Le nombre entier de la seconde ligne est le nombre, pour tous les pixels, de niveaux de gris possibles moins un.
Ensuite il y a successivement 512 × 346 nombres entiers compris entre 0 et 255 (inclus), un par ligne du fichier,
chacun d’eux définissant le niveau de gris, ou valeur, d’un pixel : 0 correspond au noir, 255 au blanc, les valeurs
intermédiaires à des gris plus ou moins foncés.
Question 1 : écrire un programme constituant l’histogramme (ou distribution statistique) de l’image à partir du
fichier, c’est à dire mettant dans le premier élément d’un tableau à un indice le nombre de pixels de valeur 0, dans
le second le nombre de pixels de valeur 1, etc. jusqu’au nombre de pixels de valeur 255. On ne demande pas les
instructions permettant de tracer cet histogramme avec gnuplot.
Avec la photo de gauche de la figure 2 le résultat serait l’histogramme de gauche de la figure 1.
4000 4000
3500 3500
3000 3000
2500 2500
2000 2000
1500 1500
1000 1000
500 500
0 0
0 50 100 150 200 250 0 50 100 150 200 250
Fig. 3 – A gauche l’histogramme de l’image originale, à droite l’histogramme de l’image modifiée
On observe sur cet histogramme qu’il y a très peu de pixels de valeur inférieure à environ min=25 ou supérieure à
environ max=160. On peut améliorer l’image en modifiant les valeurs des pixels de façon à ce que leur histogramme
occupe toute la gamme de 0 à 255. On constitue donc une nouvelle image en modifiant la valeur de chaque pixel par
la fonction affine

vi − min
vf = Partie entière ∗ 255 où vi est la valeur initiale du pixel et vf sa valeur finale
max − min
Un pixel de valeur min se retrouve ainsi à 0, un pixel de valeur max à 255. Les pixels de valeur inférieure à min doivent
être mis à 0, ceux de valeur supérieure à max à 255.
Question 2 : compléter le programme précédent pour qu’il constitue la nouvelle image dans un second fichier nommé
volcan 2.pgm et le nouvel histogramme dans un second tableau.
Les résultats obtenus sont présentés sur les figures 1 et 2. Le nouvel histogramme contient de nombreux « trous
» parcequ’on utilise des nombres entiers, mais cela n’a pas beaucoup d’importance.
Fig. 4 – A gauche l’image originale, à droite l’image modifiée. La différence serait mieux visible sur un écran ou du
papier photo (voir corrigé).
Réponse :
//-----------------------------------------------------------------------------------------------------
int main()
{
int i,nl,nh,x,xx,prof,min,max;
fstream ima("volcan_1.pgm",ios::in); // Ouverture du fichier de l’image d’origine

ima >> nl >> nh;
ima >> prof;
int *hh=I_1(prof+1);
// Constitution de l’histogramme de l’image d’origine
for(i=0;i<=prof;i++) hh[i]=0;
for(i=0;i<nl*nh;i++)
{
ima >> x;
hh[x]++;
}
ima.close();
for(i=0;i<=prof;i++) cout << hh[i] << endl;
// Relecture du fichier de l’image d’origine pour constituer l’image modifiée et son histogramme
fstream imb("volcan_1.pgm",ios::in); // Ré-ouverture du fichier de l’image d’origine
fstream imc("volcan_2.pgm",ios::out); // Ouverture du fichier de l’image modifiée
imb >> nl >> nh;
imb >> prof;
imc << nl << " " << nh << endl;
imc << prof << endl;
for(i=0;i<=prof;i++) hh[i]=0;
min=25; max=160;
for(i=0;i<nl*nh;i++)
{
imb >> x;
xx=(int)(((double)x-min)/(max-min)*prof);
if(xx<0) xx=0; else if(xx>prof) xx=prof;
imc << xx << endl;
hh[xx]++;
}
cout << endl;
for(i=0;i<=prof;i++) cout << hh[i] << endl;
return 0;
}
//-----------------------------------------------------------------------------------------------------
Température d’une sphère *** (8) [54 lignes]

Une sphère pleine homogène, de rayon R, initialement à la température uniforme T0 est plongée dans un milieu de
température Te . La température en un point de la sphère situé à la distance r de son centre vaut à l’instant t :
r
T (r, t) − Te
+∞ sin ωk
R exp −ω 2 at
X
= ck r k 2 (1)
T0 − Te ωk R
k=0
R
a est la diffusivité thermique.
Les ωk sont les solutions strictement positives de l’équation
ω
tan ω = (2)
1 − Bi
Bi est un paramètre nommé nombre de Biot, sans dimension, dont la valeur peut varier dans l’intervalle ]0, +∞[.
ω
Les ωk sont donc les abscisses strictement positives des intersections de la courbe de tan ω avec la droite , qui
1 − Bi
1
passe par l’origine et a pour pente . La droite varie de la façon suivante en fonction de Bi :
1 − Bi
lorsque Bi décrit l’intervalle ]0, 1[ la pente décrit l’intervalle ]1, +∞[, l’angle de la droite avec l’axe hori-
π π
zontal décrit ] , [
4 2
lorsque Bi décrit l’intervalle ]1, +∞[ la pente décrit l’intervalle ] − ∞, 0[, l’angle de la droite avec l’axe
π
horizontal décrit ] − , 0[
2
π π π
l’angle de la droite avec l’axe horizontal décrit donc ] − , [ sauf [0, ].
2 2 4
Les figures ci-dessous donnent deux exemples, l’un pour Bi = 0.3, l’autre pour Bi = 2.
10
Bi=0.3
ω
0
π/2 π 3π/2 2π 5π/2 3π 7π/2
-5
-10
0 2 4 6 8 10 12
Fig. 5 – Les ωk sont aux intersections des verticales en pointillés avec l’axe horizontal. La droite oblique de pente
ω
positive est la droite
1 − Bi
10
Bi=2
π/2 π 3π/2 2π 5π/2 3π 7π/2 ω

0
-5
-10
0 2 4 6 8 10 12
Fig. 6 – Les ωk sont aux intersections des verticales en pointillés avec l’axe horizontal. La droite oblique de pente
ω
négative est la droite
1 − Bi
Une étude des racines de l’équation (2) en fonction des valeurs de Bi donne le résultat suivant
π
0 < Bi < 1 : il y a une et une seule racine ωk dans chaque intervalle ouvert ]kπ, +kπ[ avec k = 0, 1, ..., +∞
2
π
Bi = 1 : on prolonge les racines par continuité aux valeurs ωk = + kπ avec k = 0, 1, ..., +∞
2
π
1 < Bi : il y a une et une seule racine ωk dans chaque intervalle ouvert ] + kπ, (k + 1)π[ avec k =
2
0, 1, ..., +∞
On calcule la racine se trouvant dans l’intervalle ouvert ]α, β[ de la façon suivante (dichotomie) :
on pose
ω α+β
f (ω) = tan ω − et γ=
1 − Bi 2
puis on applique la procédure
si f (γ) = 0 la racine cherchée est γ
si f (γ) > 0 la racine cherchée est dans l’intervalle ]α, γ[, on prend donc un nouveau β égal à γ, on calcule
le nouveau γ et on recommence la procédure à son début
si f (γ) < 0 la racine cherchée est dans l’intervalle ]γ, β[, on prend donc un nouvel α égal à γ, on calcule
le nouveau γ et on recommence la procédure à son début
β−α
Si on ne tombe pas sur la racine l’intervalle se rétrécit en progression géométrique et quand est inférieur à
α
ε = 10 −13
par exemple, on prend α ou β comme valeur approchée de la racine.
Les ck sont donnés par l’expression
sin ωk − ωk cos ωk
ck = 2
ωk − sin ωk cos ωk
Le dénominateur ne peut être nul que si ωk = 0, or on a exclu cette solution, donc il ne peut jamais être nul.
T (r, t) − Te
Question : écrire un programme qui calcule pour Bi , r et t quelconques, la somme dans l’équation (1)
T0 − Te
étant limitée à N termes. On pourra prendre a = 2.10 , Bi = 0.3, R = 0.2, r = R/2, t = 105 , tout en unités SI, et
−7
N = 20.
(D’après Transferts thermiques, Bruno Chéron, p. 51.)

Réponse :
double g_c,g_pi=acos(-1),g_Bi=0.3;
//-----------------------------------------------------------------------------------------------------
double ff(double x)
{
return tan(x)-g_c*x;
}
//-----------------------------------------------------------------------------------------------------
// ]a,b[ doit contenir une racine et une seule
double racine(double a,double b)
{
static double eps=1.e-13;
double xa,xb,xc,u;
xa=a; xb=b;
while(1)
{
xc=(xa+xb)/2.; u=ff(xc);
if(u==0.) return(xc);
else
{
if(u>0.) xb=xc;
else xa=xc;
}
if(fabs((xb-xa)/xa)<eps) return xa;
}
}
//-----------------------------------------------------------------------------------------------------
double sinc(double x)
{
if(x==0.) return 1; else return sin(x)/x;
}
//-----------------------------------------------------------------------------------------------------
int main()
{
int i,N=20; // N nb de termes de la série
double y,xinf,xsup,a=2e-7,R=0.2,z=a/R/R,t=1e5,r=R/2,temp;
double *om=D_1(N),*c=D_1(N);
// Calcul des om[i]
if(g_Bi==1.) for(i=0;i<N;i++) om[i]=i*g_pi+g_pi/2;
else
{
g_c=1/(1-g_Bi);
for(i=0;i<N;i++) {xinf=i*g_pi; if(g_Bi>1.) xinf+=g_pi/2; xsup=xinf+g_pi/2; om[i]=racine(xinf,xsup);}
}
// Calcul des c[i] et de la température
for(temp=0,i=0;i<N;i++)
{
c[i]=2*(sin(om[i])-om[i]*cos(om[i]))/(om[i]-sin(om[i])*cos(om[i]));
y=om[i]*r/R; temp+=c[i]*sinc(y)*exp(-om[i]*om[i]*z*t);
}
cout << temp << endl;
return 0;
}
//-----------------------------------------------------------------------------------------------------
Commentaire :
En calculant la température en fonction de r et de t on obtient la surface
Bi=10
1.1
1
0.9
0.8
0.7
0.6
0.5
T 0.4
0.3
0.2
0.1
0
0
10
20
30
40
50 position
0 60
10 20 70
30 40 80
50 60 90
70 80
temps 90 100 100
Fig. 7 – Evolution de la température en fonction du temps
On vérifie que la température évolue plus lentement au centre de la sphère que sur les bords.

Examen 04 03 08 Avec Corrige

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Examen 04 03 08 Avec Corrige

Transféré par

Droits d'auteur :

Formats disponibles

Numéro d’anonymat : 1 2008-03-05 01 :24 :46.

UNIVERSITE DE PARIS SUD Centre d’Orsay 2007-2008 première session d’examen

L3 et Magistère 1ère année de Physique fondamentale

Examen d’informatique Mardi 4 Mars 2008 14h à 16h bât. 337

Aucun document n’est autorisé.

Vecteurs perpendiculaires * (2) [12 lignes]

Résultats * (2) [3 lignes]

Probabilité * (7) [17 lignes]

Fig. 1 – Probabilité de chevauchement en fonction de r

Intersection d’intervalles ** (6) [17 lignes]

Frottement solide ** (7) [16 lignes]

Fig. 2 – Position de la masse en fonction du temps

La masse s’arrête en une seconde.

Histogramme d’une image ** (8) [37 lignes]

Fig. 3 – A gauche l’histogramme de l’image originale, à droite l’histogramme de l’image modifiée

fstream ima("volcan_1.pgm",ios::in); // Ouverture du fichier de l’image d’origine

Température d’une sphère *** (8) [54 lignes]

π/2 π 3π/2 2π 5π/2 3π 7π/2 ω

(D’après Transferts thermiques, Bruno Chéron, p. 51.)

Fig. 7 – Evolution de la température en fonction du temps

Vous aimerez peut-être aussi