MINISTERE DE L’ENSEIGNEMENT SUPERIEUR ET DE LA RECHERCHE SCIENTIFIQUE

******
UNIVERSITE d’ABOMEY-CALAVI

******

ECOLE POLYTECHNIQUE D’ABOMEY-CALAVI

******

SECTEUR INDUSTRIEL /DEUXIEME ANNEE

******

INITIALISATION AUX LOGICIELS DE BASE : MATLAB

Rapport du TD no1/TP MATLAB

(Courbes, fonctions 'Boucles et Zéros
de fonctions)

MEMBRES DU GROUPE: SOUS LA SUPERVISION DE:

1-CHATIGRE Larissa M. GBAGUIDI Brice

2-YEHOUENOU Chrysostome Thomas
3- PIEUMEDONO Virgile
4-SAGBO Rolande
5-SOUDE Christian

ANNEE SCOLAIRE : 2022-2023

 PLAN
Introduction
Développement
Conclusion
Annexes
 INTRODUCTION

La programmation est l’ensemble des activités qui permettent l’écriture des

programmes informatiques. L’écriture d’un programme se fait dans un langage de
programmation .Ainsi, comme langage, nous utilisons ici MATLAB (Matrix
LABoratory) qui permet de faire du calcul matriciel, de développer et d’exécuter
des algorithmes, de créer des interfaces utilisateurs (IU) et de visualiser des
données. Grâce à ce langage, nous traiterons donc dans la suite, différents exercices
basés sur les notions de fonctions, tracé de courbes, factorielles, série de Fourier et
autres qui nous permettront de mettre en exergue les différentes fonctionnalités de
ce langage.
 Développement

1 Courbes. Fonctions. Boucles

Exercice 1.1 : Tracé de fonctions (tracefoncs)
Tracer les courbes des fonctions suivantes (quand 2 courbes sont indiquées, les
superposer). On écrira un fichier de commandes contenant toutes les instructions
plot séparées par l’instruction pause.

– y = √(𝑥 2 − 𝑥) et y = x − 1/2 sur [1, 3]

– y = sin(sin x) sur [0, 2π]

– y = J0(x) et y = J1(x) (J0 et J1 fonctions de Bessel de première espèce) sur [0, 10π]

– y = J0(x) et y = sin (x + π/4)/ √ x sur [π/4, 10π]

– y = erf(x) (fonction erreur) sur [−3, 3]

Exercice 1.2 : Calcul de factorielle (facto)

Ecrire un programme qui calcule n! pour une valeur de n que l’on définira.
Pour une valeur de n=50, après exécution du programme, on obtient
>> facto
Entrez une valeur 50
Son factoriel est:
3.0414e+64

Exercice 1.3 : Calcul d’une série (calserie)

Calculer la série:
+∞ 1
S = ∑𝑛=1
𝑛²

On tronquera la sommation lorsque le terme général sera inférieur à 10-8 fois la

somme partielle. Comparer le résultat numérique au résultat exact (= π²/6 comme
chacun sait :-).
Suite à l’exécution du programme pour n=1 et S=0 au départ, on obtient le résultat
ci-dessous :
>> calserie
n
7798
Tn
1.6445e-08
S
1.6448

Exercice 1.4 : Fonctions définies par morceaux (tracefoncs2)

Tracer les courbes des fonctions suivantes (il n’est pas obligatoire d’écrire un fichier
de fonction).

y = 1 + x, pour x ∈ [−1, 0],

y= y = 1 − x, pour x ∈ [0, 1],
y = 0 sinon
 y = −(x + 1)² , pour x < −1
3/2
y= y = (x + 1) , pour x ∈ [−1, 0],
3
y = x² + x + 1 pour x ∈ [0, 2],
2
11
y= x − 3 pour x > 2
2

Exercice 1.5 : Ecriture d’une fonction (g et testg)

– Ecrire une fonction appelée g, qui traduit la fonction mathématique
g(x)=xlog(x2+1).
– Utiliser cette fonction pour évaluer g(1).
– Tracer la fonction g sur [0, 10]
Suite à l’écriture de la fonction g dans MATLAB, l’on utilise ce dernier pour
évaluer g(1) et tracer la fonction g sur [0, 10] :
>> testg
g(1)
0.3010
Exercice 1.6 : Ecriture d’une fonction n! (ffact)
Ecrire une fonction ffact qui reçoit un argument en entrée et calcule sa factorielle.
Pour une valeur de n=50, après exécution du programme, on obtient :
>> fonctionfact
x
3.0414e+64

Exercice 1.7 : Courbes d´définies en polaires (courbespol)

Avec la fonction de conversion pol2cart et l’instruction plot, tracer les courbes
définies en polaires par :
– r = 1 + e cos θ
1
–r=
(1 + 𝑒 𝑐𝑜𝑠 𝜃)

–r=1
On prendra pour e une valeur entre 0 et 1. Reprendre l’exercice avec la commande
polar (on regardera l’aide en ligne).
Avec la fonction de conversion pol2cart et l’instruction plot, on obtient les courbes
suivantes :
 Pour e=0, on :

 Pour e=1, on a :

Après reprise de l’exercice avec la commande polar on obtient :

 Pour e=0, on a :
  Pour e=1, on a :

Exercice 1.8 : Illustration des séries de Fourier (fourier)

On considère la fonction sur l’intervalle [0, 2π] :
1 si 0 < x ≤ π
f(x)= (A)
0 sinon
1. Ecrire une fonction MATLAB carre codant cette fonction mathématique. La
fonction doit pouvoir s’appliquer indifféremment `a un scalaire ou terme à terme
à un tableau de dimension quelconque. Ecrire un programme principal pour tracer
la fonction.
2. On peut montrer que cette fonction f(x) coïncide sur [0, 2π] avec la série de
Fourier :
+∞ 1−(−1)𝑛
g(x) = ½+ ∑𝑛=1 sin(𝑛𝑥) (B)
𝑛²

Ecrire un programme MATLAB qui construit progressivement la série, et qui trace

la fonction obtenue à chaque ajout d’un nouveau terme. Vérifiez que l’on retrouve
bien, pour un grand nombre de termes, la fonction f(x).
Suite à l’écrire de la fonction MATLAB carre codant cette fonction mathématique
(A) et un programme principal pour tracer la fonction on obtient ;
Le programme MATLAB qui construit progressivement la série (B), et qui trace la
fonction obtenue à chaque ajout d’un nouveau terme permet d’obtenir la courbe
suivante :

Exercice 1.9 : Utilisation de global (vdw et testvdw)

On souhaite écrire une fonction représentant l’équation d’état de Van der Waals
d’un gaz donné :
p=
Mais on impose que la fonction n’ait que 2 arguments d’entrée v et T, et 1 argument
de sortie p, les autres grandeurs a, b et R étant considérées comme des constantes
(on donne R = 8.32, a = 0.5547 et b = 3.0516 × 10−5 en unités S.I.).
1. Trouvez une solution avec l’aide du polycopié et de l’intervenant, et écrivez
la fonction.
 2. Ecrire un programme qui trace p en fonction de v pour T = 200K, T = 300K
et T = 1000K, sur un même graphique. On prendra v variant entre 1.1b et 10b.
En remplaçant R, a, et b par leur valeurs respectives et en prenant T = 200K et
v= 3.4x10−4, on obtient :
>> vdw
p
5.8903e+05
Pour des variations de T et v, on obtient :

Exercice 1.10 : Ecriture d’une fonction de plusieurs variables

Pour calculer la capacité calorifique Cp d’un gaz en fonction de la température T
(en Kelvin), on dispose de corrélations du type :
C/T E/T
Cp(T) = A + B ( )² + D ( )²
sinh(C/T) sinh(E/T)

Il est souvent intéressant de calculer également la primitive de cette fonction, qui

s’exprime par :
Ip(T) = ∫ 𝐶𝑝(𝑇)𝑑𝑇
1 1
=AT+ BC - DE
tanh(C/T) tanh(E/T)
1. Ecrire dans un fichier une fonction MATLAB appelée cpip qui reçoit en entrée
la température T et les coefficients A, B, C, D, E, et calcule Cp et Ip en sortie. On
spécifiera le nom du fichier utilisé.
2. Ecrire un programme MATLAB qui utilise la fonction précédente pour tracer
Cp(T) et Ip(T) sur l’intervalle T ∈ [250 K, 3000 K].
3. Pour des raisons pratiques, on veut que la fonction n’ait comme argument
d’entrée que la température T. Comment faire ? Réécrivez la fonction et le
programme.
En prenant pour valeur T=250, A=10, B=12, C=14, D=15, E=11, on obtient :
>> resutatcpip
Cp =
36.9778
Ip =
1.7507e+03
Le tracé de Cp(T) et Ip(T) sur l’intervalle T ∈ [250 K, 3000 K] donne l le graphe
ci-dessous :

En ayant que T comme variable d’entré, les autres variables d’entré deviennent
alors des valeurs constantes et fixes qui ne peuvent pas varier. Ainsi l’on peut écrire
une nouvelle fonction et un nouveau programme.
Exercice 1.11 : Projection de Mercator
Pour tracer des cartes géographiques, on utilise la projection de Mercator qui à un
point d’une surface sphérique fait correspondre un point du plan. La projection est
donnée par :
x=θ
𝜋 𝜑
y = log ([tan( + )]
4 2

où θ ∈ [0˚, 360˚] est la longitude et φ ∈ [−90˚, 90˚] la latitude.

1. Ecrire une fonction MATLAB effectuant la projection, qui renvoie les

coordonnées (x, y) sur la carte en fonction des deux coordonnées géographiques θ
et φ.

2. On vous fournit un fichier texte de données géographiques [Link], organisé

en deux colonnes (latitude, longitude), exprimées en degrés, d’écrivant les
frontières des continents. Ecrire un programme utilisant la fonction précédente
pour tracer la projection de Mercator des continents.

Note : on utilisera la fonction plot pour tracer point par point, sinon ça a une drôle
de tête. . .

Après la projection des coordonnées (x,y), on obtient :

 N’ayant pas le fichier texte de données géographiques [Link], nous avons
créé un fichier [Link] dont les points de la longitude sont pris dans l’intervalle
[0˚, 360˚] et ceux de la latitude dans [−90˚, 90˚]. Nous obtenons ainsi :

Exercice 1.12 : Perte de charge dans un tube

La perte de charge (= chute de pression) d’un fluide s’écoulant dans une longueur
L de tuyauterie s’écrit :
1 𝐿
∆p = f ρv²
2 𝐷

où v est la vitesse du fluide (m/s), ρ sa masse volumique (kg/m3), L et D longueur

et diamètre du tuyau (m), et f est un coefficient sans dimension que l’on peut
calculer par l’expression :
1 6.9 𝜖/𝐷
= −1.8 log10 [ +( )1.11]
√𝑓 𝑅𝑒 3.7

où Re est le nombre de Reynolds = ρDv/η, avec η viscosité dynamique du fluide

(kg.m−1 .s−1), et 𝜖 est la rugosité du tuyau (m).
Votre chef s’angoisse un peu et vous dit :
“Moi je n’y comprends rien à tout ¸ca, et je veux juste calculer la chute de pression
dans des conduites en acier qui font toujours 3 cm de diamètre, où s’écoule de l’eau
à température ambiante, en fonction du débit volumique Q (m3/s) et de la longueur
L. Ecris-moi une fonction ayant deux paramètres d’entrée Q en m3/s et L en m, et
qui me sorte la chute de pression ∆p en Pa (unité SI de la pression). Tu me feras
aussi un programme principal qui teste ta fonction pour un débit de 10−3 m3/s sur
un tube de 50 m.”
Vous décidez de ne pas discuter et de vous exécuter, et comme vous êtes bon
programmeur, vous vous interdisez d’écrire un quelconque paramètre numérique
dans la fonction (hormis ceux intervenant dans la formule (7)).
On rappelle que le débit volumique Q (en m3/s) est relié à la vitesse v (en m) par :
𝐷²
Q=π v
4
avec D exprimé en m, et on vous fournit les données suivantes :
– pour l’eau à 20◦C, ρ = 1000 kg/m3, η = 10−3 kg.m−1 .s−1,
– rugosité de l’acier commercial 𝜖 = 46 µm.
Suite à l’exécution du programme on a :
>> test_fonction_perte_pression
Vp =
6.1043e+04

2 Zéro de fonctions
Exercice 2.1 : Recherche de zéros de fonctions (zbessel)
Chercher les 20 premiers zéros de la fonction de Bessel de première espèce J1 (x).
Pour trouver une estimation de chaque zéro, on comparera graphiquement cette
fonction à sin (x−π/4). Pour calculer la fonction J1 en un point x donné, on écrit en
MATLAB : besselj (1, x)
Ces zéros sont nécessaires pour calculer des solutions données sous forme de série
d’équations aux dérivées partielles faisant intervenir le Laplacien en coordonnées
cylindriques.
Ainsi en appliquant la fonction zbessel, on obtient :
Exercice 2.2 : Utilisation d’une LED
On branche une LED en série avec une résistance R, et on la connecte sur une
source de tension U0 (Fig. 1). On note I le courant dans la branche, traversant à la
fois la diode et la résistance.

Fig. 1 – Circuit d’alimentation d’une LED

La LED est modélisable par la caractéristique :
ID = ID0 exp (UD /UD0)
et la loi des mailles appliquée au circuit 1 fournit l’équation :
U0 = UD + UR
Reformuler cette expression sous la forme f(I) = 0 et écrire un programme
MATLAB qui résoud cette équation avec la fonction fzero. On donne :
UD0=0.265 V, ID0 = 778 nA, R = 5 Ω, U0 = 12 V.
Suite à la résolution de cette équation on a :
>> led
fun =
function_handle with value:
@(I)I-(778*10^-9)*exp((12-5*I)/0.265)
z=
1.6286

Exercice 2.3 : Zéros de fonctions : calcul d’un équilibre chimique (eqchimique,

feqchimique)
On considère la réaction chimique de dissociation du dioxyde de carbone en phase
gazeuse :

La loi d’action de masse fournit indirectement la fraction molaire x en CO à

l’équilibre par :
2α
x=
2+α

où α taux de conversion est solution de

𝛼 3/2
Ke(T) =
(1 − α)(2 + α)1/2

où T la température en K et Ke(T) la constante d’équilibre. On supposera qu’une

formule approximative pour Ke(T) est :
−34000
ln(Ke) = + 10.4
𝑇

En utilisant la fonction fzero, trouver la valeur de x aux températures T = 300K,

1000K, 2000K.
On obtient après utilisant de la fonction fzero :
>> eqchimique
X=
0.6667
Exercice 2.4 : Point de fonctionnement d’un circuit hydraulique
On alimente un circuit hydraulique dans lequel circule de l’eau à température
ambiante, avec une pompe dont elle sait qu’elle augmente la pression de :

où Q est le débit volumique dans le circuit (m3/s), et pM, Qm sont des paramètres
donnés par le constructeur. Cette différence de pression est aussi la perte de charge
le long de la tuyauterie sur laquelle elle est branchée, qu’on peut calculer par les
expressions (3) et (7).

1. Ecrire l’équation permettant de déterminer le débit Q sous la forme f(Q) = 0.

2. Ecrire un programme MATLAB pour la résoudre. Toutes les données
numériques devront être définies dans le programme principal.
3. Tester votre programme pour calculer le débit sur un tube de L = 100 m, puis
sur un tube de L = 200 m. Calculer également dans les deux cas, la différence de
pression ∆p, la vitesse d’écoulement dans le tube, et le nombre de Reynolds.
4. Le constructeur de la pompe préconise que le rapport Q/Qm soit compris entre
0.5 et 0.7. Ces conditions de fonctionnement sont-elles respectées dans les deux
cas ?
Données : celle de l’exercice précédent, Qm = 1.7 × 10−3 m3/s, pM = 2.8 × 105 Pa
Pour la résolution de cet exercice, on obtient les résultats suivants
>> circuit_hydraulique
Y=
function_handle with value:
@(Q)(8*p*L*Q^2/pi^2*D^5)*(-
1.8*log10((6.9*pi*n*D)/(4*p*Q)+((e/D)/3.7)^1.11))^(-2)-pM*(1-Q^2/Qm^2)
Q=
0.0017
Vp =
6.2172e-11
V=
2.4050
Re =
7.2150e+04
 CONCLUSION
MATLAB est l’un des meilleurs langages de programmation utilisé par les
ingénieurs. Grace à ce dernier, nous avons pu ainsi trouver solution à chaque
exercice de ce rapport. L’application de ces exercices sur MATLAB nous a permis
à mieux cerner le langage, ces fonctionnalités qui par la suite nous aideront dans la
résolution de problème d’ingénieur.
 ANNEXES
Dans cette partie, nous donnerons les codes utilisés pour résoudre les différents
exercices.

1 Courbes. Fonctions. Boucles

Exercice 1.1 : Tracé de fonctions (tracefoncs)
%y = sqrt((x^2-x)) et y1 = x-1/2 sur [1,3]
x=1:0.1:3;
y=sqrt(x.^2-x);
y1=x-0.5;
plot(x,y,'b',x,y1,'y');
xlabel('x');
ylabel('y');
legend('y','y1');
grid on;

pause(5)

%y = sin(sin x) sur [0,2*pi]

x=0:0.01:2*pi;
y=sin(sin(x));
plot(x,y);grid on;
xlabel('x');
ylabel('y');

pause(5)

%y = J0(x) et y1 = J1(x)
%(J0 et J1 fonctions de Bessel de première espèce)sur [0,10*pi]
x = 0:0.0001:10*pi;
y = besselj(0,x);
y1 = besselj(1,x);
plot(x,y,'r',x,y1,'g');
xlabel('x');
ylabel('y');
legend('y','y1')
grid on;

pause(5)

%y = J0(x) et y1 = sin(x+pi/4)/sqrt(x) sur [pi/4,10*pi]

x = pi/4 : 0.1 : 10*pi ;
y = besselj(0,x) ;
y1 = sin(x + pi/4)./sqrt(x);
plot(x,y,'c',x,y1,'m');
xlabel('x');
ylabel('y');
legend('y','y1')
grid on;

pause(5)

%y = erf(x) (fonction erreur) sur [-3,3]

x=-3:0.1:3;
y=erf(x);
plot(x,y,'r');
xlabel('x');
ylabel('y');
grid on;

Exercice 1.2 : Calcul de factorielle (facto)

%Calcul de factoriel pour tout entier naturel n
n=input('Entrez une valeur');
j=1;
for i=2:n;
j=j*i;
end
disp('Son factoriel est:');
disp(j);

Exercice 1.3 : Calcul d’une série (calserie)

%Tn:terme général
%S:Série
%n:Ordre du terme
%L'objectif de cet exercice est de trouver n
%Tel que Tn<1e-8*S
n=1;
S=0;
while 1>0
Tn=1/n^2;
S=S+Tn;
if Tn<1e-8*S
break;
end
n=n+1;
end
disp('n')
disp(n)
disp('Tn')
disp(Tn)
disp('S')
disp(S)

Exercice 1.4 : Fonctions définies par morceaux (tracefoncs2)

%Tracer de courbes des fonctions définies par intervalle
y1=[];
for x=-2:0.01:2
if ((x>=-1)&&(x<0))
y=1+x;
elseif ((x>=0)&&(x<1))
y=1-x;
else
y=0;
end
y1=[y1,y];
end
x=-2:0.01:2;
plot(x,y1,'g');
xlabel('x');
ylabel('y1');
grid on;

pause(5)

y2=[];
for x=-3:0.01:4
if (x<-1)
y=-(1+x)^2;
elseif ((x>=-1)&&(x<0))
y=(1+x)^1.5;
elseif ((x>=0)&&(x<=2))
y=x^2+1.5*x+1;
else
y=5.5*x-3;
end
y2=[y2,y];
end
x=-3:0.01:4;
plot(x,y2,'r');
xlabel('x');
ylabel('y2');
grid on;

Exercice 1.5 : Ecriture d’une fonction (g et testg)

function [y] = g(x)
%ecriture d'une fonction g
y=x.*log10(x.^2+1);
end

Pour le test nous avons utilisé le code ci-dessous

%testg
disp('g(1)')
disp(g(1))
%tracé de g sur [0,10]
x=0:0.1:10;
plot(x,g(x));
xlabel('x');
ylabel('g(x)');
grid on;

Exercice 1.6 : Ecriture d’une fonction n! (ffact)

function [x] = ffact(n)
%favorise le calcul du factoriel d'un nombre
x=n*gamma(n);
end
Pour l’obtention du résultat on emploie le code suivant
%calcul du factoriel d'un nombre
x = ffact(50);
disp('x')
disp(x)
Exercice 1.7 : Courbes d´définies en polaires (courbespol)
%Tracer les courbes définies en polaires
%Utilisation de la conversion pol2cart
%Pour e=0
beta=linspace(0,10*pi,10000)
e=0
r1=1+e.*cos(beta);
r2=(1+e.*cos(beta)).^-1;
r3=1*beta;
subplot(2,2,1);
[x1,y1]=pol2cart(beta,r1);
plot(x1,y1,'b');
subplot(2,2,2);
[x2,y2]=pol2cart(beta,r2);
plot(x2,y2,'r');
subplot(2,2,3);
[x3,y3]=pol2cart(beta,r3);
plot(x3,y3,'c');

pause(5)
%Utilisation de la conversion polar
subplot(2,2,1);
polar(beta,r1,'b');
subplot(2,2,2);
polar(beta,r2,'r');
r3=1*beta;
subplot(2,2,3);
polar(beta,r3,'c');

pause(5)

%Utilisation de la conversion pol2cart

%Pour e=1
beta=linspace(0,10*pi,10000)
e=1
r1=1+e.*cos(beta);
r2=(1+e.*cos(beta)).^-1;
r3=1*beta;
subplot(2,2,1);
[x1,y1]=pol2cart(beta,r1);
plot(x1,y1,'b');
subplot(2,2,2);
[x2,y2]=pol2cart(beta,r2);
plot(x2,y2,'r');
subplot(2,2,3);
[x3,y3]=pol2cart(beta,r3);
plot(x3,y3,'c');

pause(5)
%Utilisation de la conversion polar
subplot(2,2,1);
polar(beta,r1,'b');
subplot(2,2,2);
polar(beta,r2,'r');
r3=1*beta;
subplot(2,2,3);
polar(beta,r3,'c');
 Exercice 1.8 : Illustration des séries de Fourier (fourier)
%Fonction carré
function y1=fourrier(x)
y1=[];
for x=linspace(0,2*pi,100)
if (x>0)&&(x<=pi)
y=1;
else
y=0;
end
y1=[y1,y];

end

Pour le tracé des courbes, on utilise le code suivant

%Tracé de la courbe de série de fourrier
%Similarité entre la courbe de la fonction f et
%Celle de la série de fourrier à un certain ordre n
x=linspace(0,2*pi,100);
y1=fourrier(x);
plot(x,y1,'r');
xlabel('x');
ylabel('y1');
grid on;

pause(5)

g=1/2;
n=1;
for i=1:999
A=[];
x=linspace(0,2*pi,100);
S=((1-(-1)^n)/n*pi)*sin(n*x);
g=g+S;
A=[A,g];
plot(x,A,'m');
xlabel('x');
ylabel('A');
grid on;
n=n+1;
disp(n)
end

Exercice 1.9 : Utilisation de global (vdw et testvdw)

function [p] = testvdw(v,T)
%Argument d'entré
% v:Volume
% T:Température
%Argument de sortie
% p:Pression
p=(8.32*T/(v-3.0516*1e-5))-0.5547/v.^2;
end

Pour le tracé de la courbe on utilisera le code ci-après

%Tracé de courbe p en fonction de v
%Pour T = 200K, T = 300K et T = 1000K
v=3.41e-4;
T=200;
[p]=testvdw(v,T);
disp('p')
disp(p)
pause(5)
b=3.0516*1e-5;
P1=[];
for T=[200,300,1000]
A=[];
for v=linspace(1.1*b,10*b,100)
[p]=testvdw(v,T);
A=[A;p];
end
P1=[P1,A];
end
v=linspace(1.1*b,10*b,100);
plot(v,P1);
xlabel('v');
ylabel('P1');
grid on

Exercice 1.10 : Ecriture d’une fonction de plusieurs variables

function [Cp,Ip] = cpip(T,A,B,C,D,E)
%Arguments d'entrée
% A,B,C,D,E
% T:Température
%Arguments de sortie
% Cp:Capacité calorifique
% Ip:Primitive de Cp
Cp=A+B*((C/T)/sinh(C/T)).^2+D*((E/T)/sinh(E/T)).^2

Ip=A*T+B*C*1/tanh(C/T)-D*E*1/tanh(E/T)

end

Pour déterminer Cp et Ip et tracer la courbe on utilise le code suivant

%Détermination de Cp et Ip
T=250;
A=10;
B=12;
C=14;
D=15;
E=11;
[Cp,Ip]=cpip(T,A,B,C,D,E)

pause(5)

%Tracer des courbes Cp(T) et Ip(T)

Cp1=[];
Ip1=[];
for T=[Link];
A=10;
B=12;
C=14;
D=15;
E=11;
[Cp,Ip]=cpip(T,A,B,C,D,E);
Cp1=[Cp1,Cp]
Ip1=[Ip1,Ip]
end
T=[Link]
plot(T,Cp1,'y',T,Ip1,'r');
xlabel('T');
ylabel('Cp1 et Ip1');
grid on

En considérant T comme la seule valeur d’entrée et en conservant les valeurs

prisent auparavant pour A, B, C, D et E la réécriture de la fonction et du
programme donne ce qui suit

function [Cp,Ip] = cpip(T)

%Arguments d'entrée
% T:Température
%Arguments de sortie
% Cp:Capacité calorifique
% Ip:Primitive de Cp
Cp=10+12*((14/T)/sinh(14/T)).^2+15*((11/T)/sinh(11/T)).^2

Ip=10*T+168/tanh(14/T)-165/tanh(11/T)

end

Exercice 1.11 : Projection de Mercator

function [x,y] = Mercator(lon,lat)
%Argument d'entrée
% lon:Longitude
% lat:Latitude
%Argument de sorie
%(x,y):Coordonnées géographiques
x=lon;

y=log(tan(pi/4+lat/2));
end

Pour les différentes projections de x et y on utilise le code ci-après

%Projection des coordonnées x et y
lat=linspace(-pi/2,pi/2,100);
lon=linspace(0,2*pi,100);
[x,y] = Mercator(lon,lat);
plot(x,y);
xlabel('x');
ylabel('y');
grid on

pause(5)

%Utilisation d'un fichier txt

%Pour la représentation des coordonnées
v=load('C:\Users\ADMIN\Desktop\[Link]')
x=v(:,1);
y=v(:,2);
scatter(x,y,'m');
xlabel('x');
ylabel('y');
grid on

Le fichier txt utilisé est le suivant

[Link]

Exercice 1.12 : Perte de charge dans un tube

function [Vp] = perte_pression(Q,L)
%Cette fonction permet d'évaluer la perte de charge (chute de pression)
%dans un tube

% Arguments d'entrée
% Q(débit volumique en m^3/s) et L(longueur du tube en m)
% Argument de sortie
% Vp(perte de charge d'un fluide s'écoulant dans une tuyauterie)

% D = 3*1e-2
% L = 50
% f = 0.0366
% Vp = f.*1/2*p*((4*Q)/(pi*D^2))^2*(L/D)

Vp = 0.0366.*1/2*1000*((4*Q)/(pi*0.03^2))^2*(50/0.03);

end

Pour déterminer la perte de pression on emploiera le code suivant

% Ce script permet de tester la fonction perte_pression
% Nous calculerons la perte de pression dans une tuyauterie
% Données
% p = masse volumique du fluide en Kg/m^3
% n = viscosité dynamique du fluide en kg/m/s
% e = rugosité de l'acier commercial en um
% Q = débit volumique en m^3/s
% D = diamètre de la tuyauterie en m
% L = longueur de la tuyauterie en m

p = 1000 ;
n = 1e-3 ;
e = 46e-9 ;
Q = 1e-3 ;
D = 3*1e-2 ;
L = 50 ;

Re = (4*p*Q)/(pi*n*D) ;
const = -1.8*log10(6.9/Re + ((e/D)/3.7)^1.11) ;
f = 1/const^2 ;
[Vp] = perte_pression(Q,L)

Exercice 1.12 : Perte de charge dans un tube

% Ce programme nous permet de résoudre la l'équation f(Q) = 0
pM = 2.8e5 ;
Qm = 1.7e-3 ;
L = 100 ;
D = 3e-2 ;
p = 1000 ;
n = 1e-3 ;
e = 46e-6 ;

% Résolution de l'équation

Y = @(Q)(8*p*L*Q^2/pi^2*D^5)*(-1.8*log10((6.9*pi*n*D)/(4*p*Q) +
((e/D)/3.7)^1.11))^(-2) - pM*(1 - Q^2/Qm^2)
Qo = 1e-3 ;
Q = fzero(Y,Qo)

% Calcul de la variation de pression Vp

Vp = pM*(1 - (Q/Qm)^2)

% Calcul de la vitesse d'écoulement V

V = (4*Q)/(pi*D^2)

% Calcul du nombre de Reynolds Re

Re = (4*p*Q)/(pi*n*D)

2 Zéro de fonctions
Exercice 2.1 : Recherche de zéros de fonctions (zbessel)
%Recherche de zéros de fonctions
%A l'aide de l'utilisation de bessel
y1 = @(x)besselj(1,x);
for x = linspace(0,20*pi,20)
z=fzero(y1,x);
disp(z)
end
x =linspace(0,20*pi,20)
y=sin(x-(pi/4));
y2=besselj(1,x);
plot(x,y,'r',x,y2,'c');
xlabel('x');
ylabel('y');
legend('y','y2');
grid on
Exercice 2.2 : Utilisation d’une LED
%Résolution de l'équation avec la fonctiob fzero
fun = @(I)I-(778*10^-9)*exp((12-5*I)/0.265)
z=fzero(@(I)fun(I),0)

Exercice 2.3 : Zéros de fonctions : calcul d’un équilibre chimique

function [Ke] = feqchimique(T)
%T:Température
%Ke:Constante d'équilibre

Ke = exp(-34000/T + 10.4) ;

end

Pour la détermination de la fraction molaire, on utilise le code ci-dessous

% Ce programme nous permet de trouver la valeur de alpha pour différentes
% valeurs de la température (alpha)
% T = température en K
% x = alpha

% Déterminons alpha
T =1000 ;
Ke = exp(-34000/T + 10.4) ;

[Link] = @(x)x^1.5*(1 - x)^(-1)*(2 + x)^(-0.5) - Ke ;

problem.x0 = 2 ;
[Link] = 'fzero';
[Link] = optimset(@fzero);
x = fzero(problem) ;

% Déterminons la fraction molaire X

X = 2*x/(2 + x)

Exercice 2.4 : Point de fonctionnement d’un circuit hydraulique

% Ce programme nous permet de résoudre la l'équation f(Q) = 0
pM = 2.8e5 ;
Qm = 1.7e-3 ;
L = 100 ;
D = 3e-2 ;
p = 1000 ;
n = 1e-3 ;
e = 46e-6 ;

% Résolution de l'équation

Y = @(Q)(8*p*L*Q^2/pi^2*D^5)*(-1.8*log10((6.9*pi*n*D)/(4*p*Q) +
((e/D)/3.7)^1.11))^(-2) - pM*(1 - Q^2/Qm^2)
Qo = 1e-3 ;
Q = fzero(Y,Qo)

% Calcul de la variation de pression Vp

Vp = pM*(1 - (Q/Qm)^2)
% Calcul de la vitesse d'écoulement V
V = (4*Q)/(pi*D^2)

% Calcul du nombre de Reynolds Re

Re = (4*p*Q)/(pi*n*D)