TP3 : Étude d’un pendule chargé

Dans ce TP, nous allons modéliser un cas particulier du pendule, le pendule chargé. Nous
considérons donc une tige rigide de longueur L, au bout de laquelle est accroché un corps
ponctuel de masse M et de charge q. Une deuxième charge Q est placé au point (xQ , yQ ) =
(1,5 L, 0) :

Question 1
Expression de l’énergie potentielle :

Au vu du problème, il est évident que l’énergie potentielle du pendule ne dépendra que de

l’angle θ , la longueur L étant constante.

L’énergie potentielle du pendule est dut à l’énergie potentielle de pesanteur et à l’énergie

potentielle d’interaction entre les deux charges.

L’énergie potentielle de pesanteur s’exprime :

Vpesanteur = −M gh

On pose cette énergie comme étant nulle en y = 0. On à donc la contribution de l’énergie

potentielle de pesanteur :

V (θ)pesanteur = −M gL cos θ

L’énergie potentielle d’interaction entre les deux charges s’exprime :

qQ
Vinteraction = 4π0 r

1
 p
Dans notre problème : r = (L sin θ − xQ )2 + (L cos θ + yQ )2

L’énergie potentielle totale du pendule est donc :

1 qQ
V (θ) = −M gL cos θ + p (1)
4π0 (L sin θ − xQ )2 + (L cos θ + yQ )2

Question 2
Les positions d’équilibre du pendule sont données par la première loi de Newton :
→
− →
−
ΣF = 0

On a : f (θ) = −∇V (θ)

d cos θ qQ d 1
f (θ) = M gL + p =0 (2)
dθ 4π0 dθ (L sin θ − xQ ) + (L cos θ + yQ )2
2

qQ − [2L cos θ(L sin θ − xQ ) − 2L sin θ(L cos θ + yQ )]

f (θ) = M gL sin θ + =0 (3)
4π0 2 [(L sin θ − xQ )2 + (L cos θ + yQ )2 ]3/2

qQ −L2 cos θ sin θ + LxQ cos θ + L2 sin θ cos θ + LyQ sin θ

f (θ) = M gL sin θ + =0 (4)
4π0 [(L sin θ − xQ )2 + (L cos θ + yQ )2 ]3/2

qQ LxQ cos θ + LyQ sin θ

f (θ) = M gL sin θ + =0 (5)
4π0 [(L sin θ − xQ )2 + (L cos θ + yQ )2 ]3/2

qQ xQ cos θ + yQ sin θ
f (θ) = sin θ + =0 (6)
4π0 M g [(L sin θ − xQ )2 + (L cos θ + yQ )2 ]3/2

√
On choisit la longueur L comme unité de mesure et la quantité q0 = 4π0 M gL comme
unité de charge. On prend q = q0 et Q = −2q0 . On peut donc réécrire (6) de la manière
suivante :
xQ cos θ + yQ sin θ
f (θ) = sin θ − 2 =0 (7)
[(sin θ − xQ )2 + (cos θ + yQ )2 ]3/2
En prenant xQ = 1, 5L et yQ = 0, l’équation (6) devient finalement :
3 cos θ
f (θ) = sin θ − =0 (8)
[(sin θ − 1, 5)2 + (cos θ)2 ]3/2
On développe les termes au carré du dénominateur et on obtient finalement :

3 cos θ
f (θ) = sin θ − =0 (9)
[3, 25 − 3 sin θ]3/2

2
 Figure 1 – Force s’exerçant sur le pendule en fonction de l’angle

La charge q0 est la charge caractéristique donnant la force de Coulomb nécessaire pour faire
bouger la masse M, en effet on a :

q02
= Mg
4π0 L2
La suite du problème consistera à rechercher les valeurs de θ pour lesquelles f (θ) = 0, donc
les configurations d’équilibre.

3
Question 3
Le programme suivant permet de rechercher la racine d’une fonction par la méthode de la
dichotomie :

function [ r ] = racineDicho( fun,a,b, eps)

%--------------------------------------------------------------------
% Fonction racineDicho par A. Neveu 2011
% Cette fonction recherche la racine de la fontion entree en parametre dans
% l'interval [a,b]
% Variable en entree : - fun : fonction dont on cherche la racine
% - a : borne inferieur de l'intervalle
% - b : borne superieur de l'intervalle
% - eps : precision sur le resultat (largeur du
% dernier intervalle)
% Variable en sortie : - racine obtenue, si elle existe
% Usage : [r] = racineDicho(fun,a,b,eps)
%--------------------------------------------------------------------
if a == b
sprintf('Erreur : Les bornes de l''intervalle ne doivent pas etre identiques')
return
end
if fun(a)*fun(b)>0
sprintf('Erreur : La fonction ne contient pas de zero ou contient plusieurs zero sur l''
return
end
i = 0;
while (abs(b-a))>eps

r = (b+a)/2;

if fun(r) == 0 % le milieu de l'intervalle se trouve sur la racine

return
elseif fun(b)*fun(r)<0
a = r; %
else % On reduit l'intervalle
b = r; %
end
i = i + 1;
end
sprintf('Nombre d''iteration effectuee : %d',i)
end

Question 4
On teste le programme avec la fonction f (x) = x2 − 1, donc la racine exacte sur l’intervalle
[0, 2] est 1. L’exécution de la fonction racineDicho avec la fonction f(x) définie précédemment
sur l’intervalle [0, 2] rend bien la valeur 1 attendue.

Question 5
On utilise à présent le programme racineDicho développé précédemment pour déterminer
l’angle d’équilibre stable correspondant à f (θ) = 0.

4
 Le programme rend la valeur 1.528539949778609 avec une précision de 10−4 .

Avec une précision correspondante à celle de la machine (2.220446049250313e − 16), le résul-

tat donné par le programme est : 1.528481788770989, soit une différence de 5.816100762046084e−
05. Au vu du problème étudier, on peut estimer que la précision de 10−4 est suffisante. En pro-
cédant à un petit changement dans le programme racineDicho, on rajoute une variable dans la
boucle qui à une valeur initiale de 0 et s’incrémente de 1 à chaque itération, on détermine qu’il
faut 54 itérations pour atteindre une précision de l’ordre de la précision de la machine.
g
Si on réalisait l’expérience sur une planète de gravité 10
, l’équation des configurations d’équi-
libre devient :
qQ xQ cos θ + yQ sin θ
f (θ) = sin(θ) + g =0 (10)
4π0 M 10 [(L sin θ − xQ )2 + (L cos θ + yQ )2 ]3/2
√
Avec q0 = 4π0 M gL, q = q0 et Q = −2q0 on a :

−20q02 xQ cos θ + yQ sin θ

f (θ) = sin(θ) + =0 (11)
4π0 M g [(L sin θ − xQ )2 + (L cos θ + yQ )2 ]3/2
Et donc :
xQ cos θ + yQ sin θ
f (θ) = sin(θ) − 20L2 =0 (12)
[(L sin θ − xQ )2 + (L cos θ + yQ )2 ]3/2
On prend comme au début du problème les valeur xQ = 1, 5L et yQ = 0.
On obtient finalement la relation :

30 cos θ
f (θ) = sin θ − =0 (13)
[3, 25 − 3 sin θ]3/2
On calcul ainsi que sur cette planète, l’angle d’équilibre serait : θeq = 1.57, nettement
supérieur à celui calculé sur la Terre. On s’attendait bien à ce résultat, la force attirant le
pendule vers le sol étant plus faible.

Question 6
On va maintenant supposer q 6= q0 et on note q = λq0 . On obtient donc l’équation :

3 cos θ
f (θ) = sin θ − λ =0 (14)
[3, 25 − 3 sin θ]3/2
On définit une fonction qui prend en paramètre la valeur de λ et rend la valeur de l’angle
d’équilibre correspondante :

5
function [ thetaeq ] = lambdaThetaEq( lambda)
%----------------------------------------------------------------
% Fonction lambdaThetaEq par A. Neveu 2011
% Cette fonction calcul la valeur d'equilibre du pendule en fonction
% de la valeur de lambda entree en parametre
% Variable en entree : - lambda : charge de q dans le systeme d'unite q0
% Variable en sortie : - thetaeq : angle d'equilibre du pendule
% Usage : [thetaeq] = lambdaThetaEq(lambda)
%----------------------------------------------------------------

thetaeq = racineDicho(@thetaLambda, -pi/2,pi/2,0.0001);

function [f] = thetaLambda (theta)

f = sin(theta) - lambda*(3.*cos(theta)./((-3*sin(theta)+3.25).^(3/2)));

end

end

On trace la courbe représentant l’évolution de la valeur de l’angle d’équilibre en fonction de

lambda :

Figure 2 – Évolution de la valeur de l’angle d’équilibre en fonction de λ

On représente sur le graphique suivant l’évolution du nombre de configuration d’équilibre

en fonction du paramètre λ :

6
 Figure 3 – Évolution du nombre de configuration en fonction de lambda

On remarque que pour des valeurs de λ comprise entre 0 et 1, et notamment entre 0 et 0.5,
le nombre de positions d’équilibre varie en fonction de lambda.

7
Questions théoriques
1. La bibliothèque contient 5000 volumes de 200 pages, comprenant chacune 2000 caractères.
Il y a donc 5000 ∗ 200 ∗ 2000 = 2.109 caractères.
Le code utilisé pour représenter les caractères est le code ASCII. Celui ci représente un
caractères sur 1 octet. Nous avons besoin de 2.109 octets pour stocker tous les ouvrages
de la bibliothèque. Sachant que 1M o = 220 = 1048546 octets, nous avons donc besoin
d’environ 1907,3 Mo, soit 3 cds de 650 Mo, le dernier disposant d’encore d’environ 42,7
Mo d’espace libre.

2. Une matrice 1000x1000 contient 106 nombres. En double précision il faut 64 bits pour
représenter chaque élément de la matrice. La représentation de cette matrice nécessite
donc 64 ∗ 106 bits. Pour la stocker nous avons donc besoin de 8 ∗ 106 octets, soit environ
7,6 Mo.

3. On considère une représentation binaire en virgule flottante ou la mantisse est repré-

sentée sur 4 bits et l’exposant sur 2 bits. On détermine donc un niveau d’underflow :
U F = 2−2 = 0.25. Le niveau d’overflow est : OF = 22 ∗ (1 − 214 ) = 3.75. Et la précision
de la machine est :  = 2−4 = 0.0625. Les nombres de la machine ne sont pas distribués
uniformément entre l’underflow et l’overflow, en effet ils sont plus denses autour du plus
petit non représentable par la machine :

Figure 4 – Répartition des nombres entre underflow et overflow

4. Le nombre 93 s’écrit en binaire : 1.26 + 0.25 + 1.24 + 1.23 + 1.22 + 0.21 + 1.20 , soit 1011101.

On multiplie ce nombre par le nombre binaire 101 :

1 1 0 1 1 0 1
x 1 0 1
1 0 1 1 1 0 1
0 0 0 0 0 0 0 0
1 0 1 1 1 0 1 0 0
1 1 1 0 1 0 0 0 1

Le nombre obtenu est donc 111010001. On peut vérifier en repassant en base 10 : 1.28 +
1.27 + 1.26 + 0.25 + 1.24 + 0.23 + 0.22 + 0.21 + 1.20 = 465. Le nombre 101 vaut 5 en base
10, et 93 ∗ 5 = 465 donc le calcul est vérifié.

On ajoute ensuite à ce résultat le nombre binaire 1001 :

1 1 1 0 1 0 0 0 1
+ 1 0 0 1
1 1 1 0 1 1 0 1 0

8
 On obtient donc le nombre binaire 111011010. On peut vérifier en repassant en base 10 :
1.28 + 1.27 + 1.26 + 0.25 + 1.24 + 1.23 + 0.22 + 1.21 + 0.20 = 474. Le nombre 1001 vaut 9
en base 10, et 465 + 9 = 474 donc le calcul est vérifié.

5. La formule d’Archimède permettant de calculer une approximation de π est la suivante :

p
t2i + 1 − 1
ti+1 = (1)
ti
p
En multipliant le numérateur et le dénominateur par t2i + 1 + 1, on obtient :

ti
ti+1 = p 2 (2)
ti + 1 + 1
On écrit le programme suivant qui permet de calculer une approximation de Pi par ordi-
nateur avec la relation (1) :

function [ pi ] = arch1(i )
% ----------------------------------------------------------------
% Fonction arch1 par A. Neveu 2011
% Cette fonction calcul une approximation de pi par la formule
% de recurrence d'Archimede
% Variable en entree : - i : nombre d'iteration de la recurrence
% Varibale en sortie : - pi : approximation calculee de pi
% Usage : [pi] = arch1(i)
%-----------------------------------------------------------------

t = 1/sqrt(3); % initialisation de t avec la valeur t0

for n = 1:i

t = (sqrt(t^2+1)-1)/t;

end

pi = 6*(2^i)*t;

end

On remarque que la précision de la méthode croît quand i augmente, et est maximale

pour une valeur de i = 12, avec un écart à la valeur réelle de π d’environ 1.82.10−8 .
Le graphique suivant représente l’évolution de l’erreur commise sur l’approximation de π
avec la relation (1), en fonction de i :

9
 Figure 5 – Évolution de l’erreur sur pi calculée avec la relation (1)

Le programme suivant calcul une approximation de π avec la relation (2) :

function [ pi ] = arch2(i )
% ----------------------------------------------------------------
% Fonction arch2 par A. Neveu 2011
% Cette fonction calcul une approximation de pi par la formule
% de recurrence d'Archimede
% Variable en entree : - i : nombre d'iteration de la recurrence
% Varibale en sortie : - pi : approximation calculee de pi
% Usage : [pi] = arch2(i)
%-----------------------------------------------------------------

t = 1./sqrt(3); % initialisation de t avec la valeur t0

for n = 1:i

t = t./(sqrt(t.^2+1)+1);

end

pi = 6.*(2.^i).*t;

end

Avec relation (2), on atteint une précision de l’ordre de 3.55.10−15 , avec un i = 12.
On représente cette erreur sur le graphique suivant, et on peut remarquer que l’erreur
diminue jusqu’à atteindre un palier.

10
 Figure 6 – Évolution de l’erreur sur pi calculée avec la relation (2)

Avec cette relation, la précision sur π est meilleur qu’avec la relation

p (1). En effet, dans
(1), lorsque i devient grand ti tend vers zéro. On a donc t2i + 1 qui tend vers
la relation p
1, et donc t2i + 1 − 1 qui tend également vers zéro. Pour des valeurs de i supérieur à 12,
l’underflow de la machine provoque une erreur dans le calcul.

Le programme ayant permis de représenter graphiquement l’erreur sur π calculée avec les
relations précédentes est le suivant (configurer pour le calcul de l’erreur avec la relation
(2) ) :

function [ ] = erreurArch2( imax )

%----------------------------------------------------------------
% Fonction erreurArch2 par A. Neveu 2011
% Cette fonction affiche graphiquement l'evolution de la precision
% de la fonction arch2 en fontion de du nombre d'iteration
% Variable en entree : - imax : valeur maximal de i
%
% Usage : [] = erreurArch2(imax)
%----------------------------------------------------------------

if imax - round(imax) 6= 0 || imax ≤ 0

sprintf('La fonction prend un entier positif > 0 en parametre')

else
for i=1:imax
ev(i) = pi - arch2(i);
end

semilogy(1:imax,abs(ev));

end
end

11