Vous êtes sur la page 1sur 7

Ministère de l'éducation, de la culture et de la recherche

de la République de Moldova
Université technique de Moldavie
Faculté d’Ordinateur, Informatique et Microélectronique
Filière francophone “Informatique”

Méthodes et modèles de calcul


Travail pratique nr.1
Thème: Solution numérique d'équations
algébriques et transcendantales

Effectué par l’étudiant : Botnaru Alexandru


Vérifié par : Istrati Daniela

Chişinau 2020
Variante 3 :

La méthode graphique.
a) e^x +3x=0
e^x=-3x
f1=e^x
f2=-3x
Pour résoudre cette équation transcendante, nous utilisons la méthode
graphique.

Maintenant nous écrivons cette équation sous la forme de 2 équations


simples.On peut voir que les graphiques se croisent approximativement dans
l’intervalle r ∈ [-1,0].
b) x^3 -23x-42
Pour résoudre cette équation algébrique, on vas utiliser la méthode
graphique et analytique.

La méthode graphique
x^3 -23x-42=0
x^3=23x+42
f1=x^3
f2=23x+42

On peut voir que les graphiques se croisent approximativement dans


l’intervalle r ∈ [-3,-2].

La méthode analytique (en Wolfram Mathematica)


Tout d'abord, nous devons trouver le dérivé de la fonction et le résoudre.Il faut
ensuite introduire dans la fonction initiale les valeurs de x obtenues précédemment
ainsi qu'une valeur inférieure et une valeur supérieure aux valeurs de x obtenues.

Les résultats obtenu dans le tableau :


La valeur de x -4 -2.76887 2.76887 4
La valeur de -14 0.456078 -84.4561 -70
la fonction

Dans ce cas, la fonction a des racines réelles dans les intervalles [-4, -2.76887],
[-2.76887 , 2.76887].
Fonctions permettant de résoudre le problème par d’autres méthodes : (JAVA)
1) La méthode de séquençage
public double SECANT(double x0, double x1)
{
int k = 1;
double alfa = 0.01;
double[] sirul_xk = new double[100];
sirul_xk[0] = x0;
sirul_xk[1] = x1;
while(alfa /(1 - alfa) * Math.abs(sirul_xk[k] - sirul_xk[k - 1]) > epsilon1)
{
sirul_xk[k + 1] = sirul_xk[k] - FUNCTION_F(sirul_xk[k]) *
((sirul_xk[k] - sirul_xk[k - 1])/(FUNCTION_F(sirul_xk[k]) - FUNCTION_F(sirul_xk[k - 1])));
k++;
contor_iteratii++;
}
return sirul_xk[k];
}
double FUNCTION_F(double x)
{
double fun = 0;
if(cazul == 'a')
{
fun = Math.exp(x)+3*x;
}
if(cazul == 'b')
{
fun = Math.pow(x, 3) - 23 * x - 42;
}
return fun;
}

2) Méthode de bissection
public double BISECT(double a, double b)
{
double c;
contor_iteratii++;
c = a + (b - a) / 2;
if(FUNCTION_F(c) == 0 || Math.abs(b - a) < 2 * epsilon)
{
result = c;
}
else
{
if(FUNCTION_F(c) * FUNCTION_F(a) < 0)
{
BISECT(a, c);
}
else
{
BISECT(c, b);
}
}
return result;
}
double FUNCTION_F(double x)
{
double fun = 0;
if(cazul == 'a')
{
fun = Math.exp(x)+3*x;
}
if(cazul == 'b')
{
fun = Math.pow(x, 3) - 23 * x - 42;
}
return fun;
}

3) Méthode Newton
public double NEWTON(double x0)
{
int k = 1;
double alfa = 0.01;
double[] sirul_xk = new double[100];
sirul_xk[0] = x0;
sirul_xk[1] = x0 - FUNCTION_F(x0) / FUNCTION_F2(x0);
while(alfa / (1 - alfa) * Math.abs(sirul_xk[k] - sirul_xk[k - 1]) > epsilon1)
{
sirul_xk[k + 1] = sirul_xk[k] - FUNCTION_F(sirul_xk[k]) /
FUNCTION_F2(sirul_xk[k]);
k++;
contor_iteratii++;
}
return sirul_xk[k];
}

double FUNCTION_F(double x)
{
double fun = 0;
if(cazul == 'a')
{
fun = Math.exp(x)+3*x;
}
if(cazul == 'b')
{
fun = Math.pow(x, 3) - 23 * x - 42;
}
return fun;
}
double FUNCTION_F2(double x)
{
double fun = 0;
if(cazul == 'a')
{
fun = 1 / ((Math.exp(x)*x + 3;
}
if(cazul == 'b')
{
fun = 3 * Math.pow(x, 2) - 23;
}
return fun;
}

4) Méthode d'approximation successive


public double APROX(double x0)
{
int k = 1;
double alfa = 0.01;
double[] sirul_xk = new double[100];
sirul_xk[0] = x0;
sirul_xk[1] = FUNCTION_F1(x0);
while(alfa /(1 - alfa) * Math.abs(sirul_xk[k] - sirul_xk[k - 1]) > epsilon1)
{
sirul_xk[k + 1] = FUNCTION_F1(sirul_xk[k]);
k++;
contor_iteratii++;
}
return sirul_xk[k - 1];
}
double FUNCTION_F1(double x)
{
double fi = 0;
if(cazul == 'a')
{
fi = - Math.exp(x)+3*x;
}
if(cazul == 'b')
{
fi = 37 / (Math.pow(x, 2) - 23);
}
return fi;
}

Conclusion : En effectuant ce travail de laboratoire, j’ai résolu des systèmes


numériques d’équations algébriques et transcendants, que nous avons appris dans
les cours de MMC. Pour ce faire, j’ai utilisé le logiciel de calcul formel Wolfram
Mathematica et le langage de programmation JAVA.

Vous aimerez peut-être aussi