Cahier - Complet - Technique Scientifiques 2019 - 01 PDF

!
Cahier de Techniques Scientifiques

Licence EEA - MI
Deuxième Année
P. Castelan
Université Paul Sabatier Techniques Scientifiques Numériques L2 SFA
De manière générale, il est fortement conseillé de venir en TD avec une calculatrice
TD#01
Exercice 1 : Calcul polynomial
1. Calculez : P6(1,5) avec P6(x) = 7x6 + 4x5 + 6x4 - 3x3 + 2x - 9.
2. Ecrivez un programme en langage C permettant le calcul de la valeur prise par un polynôme en un point
α sans utiliser de tableau pour le calcul. Les coefficients de P(x) et le point α seront saisis au clavier.
Exercice 2 : Division polynomiale

1. Déterminez l'expression du polynôme quotient Q(x) = P6(x) / ( x - 1,5 ) où P6(x) est le polynôme donné ci-
dessus.
2. Pouvez-vous donner dès à présent le reste ?
3. Écrivez un programme en langage C calculant les coefficients de Q(x), le polynôme quotient, tel que :  
P(x) = ( x - α )*Q(x) + R. Les coefficients de P(x) et le point α seront saisis au clavier.
Exercice 3 : Dérivées d'un polynôme

Soit P3(x) un polynôme de degré 3.
1. Ecrivez P3(x) en notation canonique décroissante.
2. Calculez R3, R2, R1 et R0 les restes des divisions successives de P3(x) par (x-α).
3. Exprimez alors P3(x) en fonction des restes R3, R2, R1 et R0.
4. Donnez l'expression générale du développement limité en série de Taylor d'une fonction f(x)
quelconque.
5. Donnez alors l'expression du dL de Taylor dans le cas où la fonction est un polynôme de degré 3.
6. En identifiant, donnez l’expression des dérivées successives de P3(x) en fonction des restes successifs.
Exercice 4 : Calcul des dérivées successives

1. Calculez les dérivées successives de P6(x) en α = 1. Donnez le tableau complet
2. Ecrivez programme C qui calcule toutes les dérivées successives d'un polynôme P(x) sans utiliser de
tableau à deux dimensions. Les coefficients de P(x) et α seront saisis au clavier.
TD#02
Exercice 5 : Lagrange : Méthode développée
Soit le tableau de données suivant :
Xi 0 2 4 6
F(x) = 3x2+2=Yi 2 14 50 110
Calculez par interpolation de Lagrange la valeur de y=F(α) pour α = 5.
Exercice 6 : Lagrange : Méthode du Tableau

Soit le tableau de données suivant :
Xi 0 2 4 5 6
Yi exp(0) exp(2) exp(4) exp(5) exp(6)
où exp est la fonction exponentielle (base e).
1. Calculez par interpolation linéaire la valeur de y pour α = 1 et comparer avec la valeur théorique.
2. Calculez par l'interpolation de Lagrange la valeur de F(1). Que constatez-vous ?
3. Proposez une méthode pour corriger le problème.
Exercice 7 : Lagrange : Avec ϕ(x)

Soit le support numérique :
X 0 1 2 3
Y = x2-x+1 1 1 3 7
Travaux Dirigés 3 P. Castelan

1. Calculer Φ(x), écrivez-le sous forme canonique.

2. À l'aide de la méthode d'Horner, calculez les Lk(x)
3. Déterminez alors l'expression littérale de Pn(x)
Exercice 8 : Vu en TP…
• Ecrivez un programme en C qui calcule la valeur du polynôme d'interpolation en un point α par la
méthode de Lagrange. On prendra soin à ne pas stocker les coefficients de Lagrange dans un tableau.  
Yn
↵ xj
Utilisez l'expression des coefficients de Lagrange Li = pour ce programme et non Φ(x).
x
j=0 i
xj
TD#03
Exercice 9 : Newton : Interpolation polynomiale
Soient les données suivantes : x0 = 0, h = 0,1, n = 6, les yi=f(xi) sont dans la liste suivante :
0 5,73 11,53 17,46 23,58 30,0 36,87
1. Construisez le tableau des différences
2. Calculez la variable réduite u pour α = 0,25
3. Calculez par interpolation la valeur de f(0,25)
Exercice 10 : Newton : Utilisation du tableau des différences

Soit le support numérique : x0 = -3, h = 1, n = 6, les yk=f(xk) sont dans la liste suivante :
Yk : 20 16 8 2 4 20 56
1. Construisez le tableau des différences
2. À la vue du tableau des différences, quel conjecture pouvez-vous faire sur f(x) ?
3. Calculez la variable réduite u pour α = 0,5
4. Calculez par interpolation la valeur de f(0,5)
5. À partir du tableau des différences, calculez f(-4) et f(4).
Exercice 11 : Programme interpolation de Newton - Travail personnel, cf. le projet de TP.

• Ecrivez un programme C qui calcule le tableau de différences, l'affiche à l'écran et calcule la valeur du
polynôme d'interpolation par le méthode de Newton en un point alpha donné.
• Les données pour le programme seront saisies au clavier.
Exercice 12 : Recherche de racines : la méthode de Newton
• En supposant que l'on connaisse xn, une approximation de α, racine de la fonction ƒ(x), exprimez !hˆ ,
l'erreur estimée en fonction de xn, en utilisant le développement limité de ƒ(x) tronqué à l'ordre 1.
Exercice 13 : Recherche de racines par Newton

• Calculez, par une méthode itérative, une racine de l'équation : cos(x) = x, où x, en radians, est dans
l'intervalle [ 0,5 ; 1 ]. On prendra comme valeur de départ 0,7. On arrêtera le processus lorsque l'erreur
sera inférieure à 10-5.
Exercice 14 : Méthodes de Newton : les limites de la méthode.

1. Déterminez les racines de P(x) = x4 - 2x2 + 1 en prenant comme point de départ x0 = 0
2. Même question avec le polynôme x3 - 6x2 + 4*x + 4, en prenant comme point de départ 0,5 puis 0,6.
Calculez les deux premières itérations.
TD#04
Exercice 15 : Méthode de Bairstow
• En utilisant Bairstow, déterminez les racines de P(x) = x3 - 2x2 - 5x + 6. On prendra S0 = P0 = 1 et ε=10-2

Exercice 16 : Bairstow, vitesse de convergence

1. En utilisant Bairstow, déterminez les racines de P(x) = x3 - 2x2 - 5x + 6. On prendra S0 = P0 = 0 et ε=10-2
2. Que constatez-vous pour les valeurs finales de S et P ?
3. Qu'en déduisez-vous concernant le choix de S0 et P0 ?
Exercice 17 : Bairstow : choix du point de départ

1. En utilisant Bairstow, déterminez les racines de P(x) = x6 + 1. On prendra S0 = P0 = 0 et ε=10-2
2. Quel est le meilleur choix pour les valeurs de S0 et P0 ?
Exercice 18 : Bairstow : programme C

• Ecrivez un programme en langage C qui, utilisant la méthode de Bairstow, détermine un jeu de valeurs de
S et P (sans calculer les racines, ni chercher à déterminer tous les couples de S et P).
Exercice 19 : Méthode de Dichotomie

• Trouvez la racine du polynôme P4(x) = 2x4 - 6*x3 + 7x - 1 comprise dans l'intervalle [ 0 ; 0,25 ] avec une
précision de 10-2 en utilisant l'algorithme de la dichotomie
Exercice 20 : Limites de la méthode de dichotomie

1. Déterminez la valeur d'une racine du polynôme : x4 - 12x3 + 54x2 - 108x + 81 dans l'intervalle [ 2,5 ; 3,5 ]
par la méthode de Dichotomie.
2. Vérifiez que 3 est racine à l'aide de la méthode d'Horner.
Exercice 21 : Dichotomie : programme (se référer au cours…)

• Ecrivez un programme en langage C qui détermine une racine d'une fonction F(x) par Dichotomie.
• La fonction F(x) sera définie dans une fonction C par : double F( double x).
• La précision sera définie dans une constante en début de programme égale à 10-3.
TD#05
Exercice 22 : Intégration numérique
• Retrouvez l'expression dite de "Simpson" permettant le calcul d'une intégrale. On utilisera la
x − xi
détermination du polynôme d'interpolation par la méthode de Lagrange en variable réduite : u
! =
h
Exercice 23 : Intégration numérique comment mener un calcul
4
• Estimez en utilisant la méthode des trapèzes et la méthode de Simpson l’intégrale : I! = ∫0 f (x)d x
On donne :
Xi 0 1 2 3 4
Yi 1 2 3 4 5
Exercice 24 : Intégration : précision des méthodes.

4
On donne :
Xi 0 1 2 3 4
Yi 1 2 5 10 17
Exercice 25 : Intégration : précision des méthodes.

4
On donne :
Xi 0 1 2 3 4
Yi 1 2 17 82 257

Exercice 26 : Intégration programme C

• Ecrivez un programme en langage C calculant la valeur d'un intégrale par la méthode d'intégration des
trapèzes ou de Simpson. Le choix de la méthode sera saisi par l'utilisateur à l'aide d'un caractère : 't' ou 'T'
pour Trapèzes, 's' ou 'S' pour Simpson. 
Le programme devra choisir la méthode des trapèzes si la méthode de Simpson n'est pas applicable. 
Toutes les données seront saisies au clavier.
Exercice 27 : Dérivation numérique avec une fenêtre de 4 points.

• Retrouvez l'expression de la formule à gauche pour une fenêtre de 4 points.
On donne le tableau de points suivant :
Xi 1 2 3 4
Yi 0,000 0,693 1,099 1,386
• Calculez la dérivée en chacun des points du tableau en justifiant le choix de l'expression utilisée.
Note : la fonction est Ln(x)
Exercice 28 : Dérivation numérique avec une fenêtre à 4 points d'un polynôme.

On donne le tableau de points suivant :
Xi 1 2 3 4
Yi 3 10 29 66
• Calculez les dérivées de chacun des points en utilisant les expressions des dérivées.
Note : la fonction est x3 +2
Exercice 29 : Dérivation numérique programme C (Travail personnel)

• Ecrivez un programme en langage C calculant la dérivée d'une fonction connue d'après ses points en
mettant en œuvre une fenêtre à trois points.
TD#06
Exercice 30 : Equation différentielle simple, méthode de Taylor.
1. Calculez la valeur que prend g(x) en x = {2, 3, 4 } sachant que g(x) vérifie l'équation différentielle : y' = x
en utilisant la méthode de Taylor. On précise les C.I. : x0 = 1 et y0 = 2 et le pas d'intégration h = 1.
2. Vérifiez les valeurs trouvées en intégrant l'équation différentielle.
Exercice 31 : Equation différentielle un peu moins simple, méthode de Taylor.

1. Calculez la valeur de g(x) en x = 0,3 sachant que g(x) vérifie l'équation différentielle y' = x + y. Les
conditions initiales sont x0 = 0, y0 = 0. Les calculs seront arrondis à la quatrième décimale. Vous utiliserez
la méthode de Taylor. Le pas h sera d'abord pris égal à 0,3 puis à 0,1
2. Vérifiez les valeurs trouvées en intégrant l'équation différentielle
Exercice 32 : Equation différentielle simple, méthode Runge-Kutta

• Calculez la valeur que prend g(x) en x = {2, 3, 4} sachant que g(x) vérifie l'équation différentielle : y' = x en
utilisant une méthode de Runge Kutta d'ordre 2. 
On précise les conditions initiales : x0 = 1 et y0 = 2 et le pas d'intégration h = 1.
Exercice 33 : Equation différentielle un peu moins simple, méthode de Runge-Kutta.

• Calculez la valeur de g(x) en x = 0,3 sachant que g(x) vérifie l'équation différentielle y' = x + y. Les
conditions initiales sont x0 = 0, y0 = 0. Les calculs seront arrondis à la quatrième décimale. Vous utiliserez
une méthode de Runge-Kutta d'ordre 2. Le pas h sera d'abord pris égal à 0,3 puis à 0,1.
Exercice 34 : Equations différentielle : RK2 programme C.

• Ecrivez un programme en C calculant numériquement les solutions de l'équation différentielle de
l'exercice 36. L'équation et le calcul des ki seront codés dans des fonctions différentes.

Exercice 35 : Equation différentielle simple, méthode d'Euler

• Calculez la valeur que prend g(x) en x = {2, 3, 4 } sachant que g(x) vérifie l'équation différentielle : y' = x en
utilisant la méthode d'Euler. 
On précise les conditions initiales : x0 = 1 et y0 = 2 et le pas d'intégration h = 1.
Exercice 36 : Méthode d'Euler itérative (ou corrigée)

• Calculez la valeur de g(x) en x = {2} sachant que g(x) vérifie l'équation différentielle : y' = x. Les conditions
initiales sont x0 = 1 et y0 = 2. 
Vous utiliserez la méthode d'Euler corrigée.  
Le pas sera pris égal à 1 et la précision ε égale à 0,1.

Contrat de Confiance TD
Exercice I
x 0 1 2 3
F(x) -3 -1,5 2 7,5
• Quel est le degré du polynôme d’interpolation passant par ces points ?
• Donnez l'expression de (x)
• A l'aide des méthodes de Lagrange et d'Horner déterminez les coefficients du polynôme d'interpolation.
• Calculez la somme des coefficients de Lagrange.
Exercice II
Soit P3(x) un polynôme de degré 3 s’exprimant : P3(x) = x3 - 2x2 - 5x + 6. Dans ce qui suit, tous les calculs
seront menés à l'aide de la méthode d'Horner.
• Déterminez les coefficients du polynôme quotient Q(x) résultat de la division de P3(x) par x - 2.
• Donnez la valeur du reste de la division de P3(x) par x - 2.
• Calculez la valeur de Q(x) en x=3. À l'aide de ce résultat et sans calculer directement P3(x) en x=3, donnez
la valeur de P3(x) en x=3.
Exercice III
Dans ce qui suit, tous les calculs seront menés à l'aide de la méthode d'Horner.  
Soit le polynôme : P(x) = x3-13x+12.
• Calculez la valeur de P’(x) en x=1. Donnez alors l’expression du polynôme Q1(x) = P(x)/( x - 1 ) .  
Donnez la valeur du reste de la division.
• Calculez l’expression de Q3(x) = P(x)/(x-3), de Q-4(x) = P(x)/(x+4). Donnez dans chaque cas la valeur du
reste de la division.
• Proposez à partir des résultats des questions précédentes, une écriture de P(x) en fonction de ses racines
sous la forme : P
! (x) = (x − α1)(x − α2 )(x − α3). Justifiez votre réponse.
Exercice IV
Xi -1 0 2 3
F(Xi) =Yi 11 7 5 7
• Déterminez la valeur en x=1 que prend le polynôme d’interpolation en utilisant la méthode de Lagrange.
• Que vaut la somme des coefficients de Lagrange ?
• La valeur théorique est Y=5 pour X=1. Quelle conjecture peut-on faire quant à la nature de la F(X) ?
Exercice V
On cherche à calculer la dérivée d'une fonction y = F(x) connue par ses points { {0 , -2}, {1 , -1}, {2 , 2} }.
Pour évaluer la dérivée en ces points, on se propose d'interpoler par la méthode de Lagrange la fonction F,
puis de dériver le polynôme obtenu.
• Donnez l'expression générale des coefficients de Lagrange. On donnera les deux formes vues en cours.
• Déterminez les coefficients des trois polynômes-coefficients de Lagrange
• Donnez l'expression littérale sous forme canonique décroissante du polynôme d'interpolation.
• Calculez la valeur de la dérivée aux points 0, 1 et 2 en utilisant la méthode de Horner
Contrat de Confiance 8 P. Castelan

Exercice VI
X 0 1 2
Y=F(X) Y0 Y1 Y2
• Donnez l’expression littérale du polynôme d’interpolation en fonction de Y0, Y1 et Y2.
• En intégrant le polynôme obtenu entre X=0 et X=2, exprimez la valeur de l’intégrale I! = ∫ 2 F (x)d x en
0
fonction de Y0, Y1 et Y2.
Exercice VIII
Soit P5(x) un polynôme de degré 5 s’exprimant : P5(x) = x5 – x4 - 13x3 + 13x2 +36x - 36
• Calculez en utilisant le schéma de Horner la valeur P5(2).
• Déterminez le polynôme quotient Q3(x) résultant de la division de P5(x) par T(x) = x2 - 9 : P5(x) = T(x)Q3(x) +
R(x). 
Pour ce faire vous rechercherez les racines évidentes de T(x) après l'avoir factorisé puis utiliserez la
méthode d'Horner pour réaliser les deux divisions.  
Au vu des résultats de vos calculs vous expliquerez pourquoi cette méthode est ici possible. 
Donnez l’expression du reste R(x).
• Calculez la valeur de Q(x),T(x) et R(x) en x=2.
• Retrouvez la valeur de P5(x) en x=2 à l'aide des valeurs calculées précédemment.
Exercice IX
d y (x)
On considère l'équation différentielle : ! = x − 2y
dx
• Calculez les valeurs prises par la fonction y(x) en x = {1, 2, 3} en utilisant la méthode de Runge-Kutta
d'ordre 2 vue en TD. On prendra un pas d'intégration h = 1 et les conditions initiales { x0 = 0 ; y0 = 1 }.
Exercice X
On veut calculer la surface sous la courbe connue par le tableau de points suivant.
X 0 1 4 5
Y 2 -1 2 27
• Donnez une approximation de cette surface en utilisant la méthode des trapèzes.
• Expliquez pourquoi on ne peut utiliser la méthode des trapèzes à pas constant pour calculer cette
surface.
• Utilisez la méthode de Lagrange pour rendre le calcul de cette intégrale par la méthode des trapèzes à
pas constant possible.
• Donnez alors une approximation de la surface en utilisant la méthode des trapèzes à pas constant.
• Comparez et commentez les deux résultats trouvés.
Exercice XI
On cherche à déterminer avec une précision de 1e-6 la racine de l’équation Loge(x)-1 = 0. Pour ce faire on
envisage d'utiliser la méthode de Newton. On indique que le logarithme utilisé est le logarithme base e.
• Etablissez l’expression de la relation de récurrence reliant deux approximations successives
• Calculez une valeur approchée de la racine avec 6 décimales en prenant comme point de départ : x0 : 2.
Exercice XII
Une mesure de courant en fonction du temps a donné le tableau de valeurs suivants :
t (s) 0 1 2 3
I (mA) 20 8 4 2
Afin déterminer avec précision l'instant où le courant devient égal à 6mA, vous procéderez de la manière

décrite ci-après.
• Déterminez l'ensemble des coefficients de l'expression canonique décroissante du polynôme
d'interpolation  
PL(t) = I(t) en utilisant la méthode de Lagrange.
• On cherche t tel que : I(t) = 6. Dans cette équation remplacez I(t) par PL(t). Donnez l'expression de
l'équation alors obtenue.
• En utilisant les méthodes d'Horner et de Newton, déterminez la valeur qui vérifie l'équation obtenue à la
question 2. Vous donnerez une valeur approchée de la racine avec une précision meilleure que 10-2. Le
point de départ sera pris égal à 1. Les calculs seront menés avec une précision de 4 décimales.
Exercice XIII
1
On considère l'équation différentielle suivante : i′! (t ) = (1 − i (t )) . On précise : τ = 0,5, et à t = 0, i(t) = 0.
τ
• Donnez la valeur du courant i(t) à t = 0,1 ; 0,2 ; 0,3 secondes en utilisant une méthode de Runge-Kutta
d'ordre 2 vue en TD et en utilisant un pas d'intégration égal à 0,1.
Exercice XIV
Soit P3(x) un polynôme de degré 3 s’exprimant : P3(x) = x3 - 2x2 - 5x + 6
• Déterminez une racine du polynôme par la méthode de Newton en prenant comme point de départ x =
2.
• Même question en prenant comme point de départ x =1,25.
La précision des calculs sera d’au moins 4 décimales. Tous les calculs polynomiaux seront menés à l’aide de
la méthode de Horner. La solution sera donnée avec une précision meilleure que 10-2.
Exercice XV
Xi -1 0 1 2 3
Yi 6 1 -2 -3 -2
• Calculez la valeur que prend le polynôme d’interpolation en x=2 par la méthode de Lagrange en utilisant
la méthode du tableau vue en TD. Pour ce calcul on ne prendra pas le point {2, -3} dans le tableau de
données ci-dessus (colonne grisée).
• Déterminez les coefficients du polynôme d’interpolation PL(x) en utilisant la méthode de Lagrange.
Exercice XVI
L'algorithme d'Héron d'Alexandrie permet d'extraire la racine carrée d'un nombre par une méthode
itérative. En utilisant la méthode de Newton (racine d'une équation), établissez cette méthode itérative.
Indication : l'équation dont on cherche la racine est g(x) - A = 0 où A est le nombre dont on cherche la racine
carrée et  
g(x) la fonction qui à x associe x2.
• Déterminez la racine carrée de 2 avec une précision meilleure que 10-4 en prenant comme point de départ
x0 = 1.
Exercice XVI
d g (x)
On considère l'équation différentielle suivante : ! = 6x + 2
dx
• Calculez les valeurs prises par la fonction g(x) en x = {0, 1, 2}. On prendra h = 1 et les conditions initiales
{ x0 = -1 ; y0 = -1 } en utilisant la méthode de Runge-Kutta d'ordre 2 vue en TD.
Exercice XVII
Nota Bene : tous les calculs de cet exercice se feront avec exactement 4 chiffres significatifs.

Un circuit à composant actif a une réponse en courant pouvant être approchée par l’expression suivante
i(v) = 10(1 − e x p (−4v)), on cherche à déterminer son point de fonctionnement en déterminant le point
d’intersection avec la droite de charge : i(v)
! = 10 − v
• En écrivant l’égalité des courants, donnez l’expression de l’équation à résoudre.
• Résolvez cette équation par la méthode de Newton en prenant comme point de départ v = 0,6 V. La
solution doit être donnée avec une précision de 0,01V.
Exercice XVIII
Nota Bene : tous les calculs de cet exercice se feront avec exactement 4 chiffres significatifs.
!
À l’instant t = 0, on ferme l’interrupteur k. À cet instant le courant dans le circuit est nul.
• Donnez la relation liant le courant i(t) à Vs(t) aux bornes de la résistance R.
• Donnez la tension Vs(t) aux temps 2.10-3, 4.10-3, 6.10-3 s en utilisant la méthode de Runge Kutta d'ordre 2
d i (t )
vue en TD après mise en forme de l’équation différentielle ! = …et détermination des conditions
dt
initiales.
Le pas d’intégration h sera pris égal à 2.10-3 s.
di
On donne l’équation différentielle gouvernant le circuit : E
! =L + R i (t )
dt
On donne R = 10 Ω ; L = 0,1H ; E = 10V.
Exercice XIX
Soit le support numérique suivant :
X -2 0 2 4 6
Y 0,25 1 4 16 64
• Calculez la valeur que prend le polynôme d’interpolation en α=1 par la méthode de Lagrange en utilisant
le tableau ci-dessus.
• La valeur trouvée vous semble-t-elle correcte ? Justifiez votre réponse.
• Les Y sont issus de la fonction f! (x) = 2x. Quelle méthode proposez-vous pour calculer une approximation
exacte ? Faites le calcul et comparez alors la valeur trouvée avec la valeur de la fonction ƒ(x) en x=1.
Exercice XX
• Comment calcule-t-on x! n+1 si l’on connaît x! n et que l’on recherche une valeur approchée d’α une racine
de f! (x) par la méthode de Newton ?
• Donnez des critères nécessaires à la convergence de la méthode de Newton. Sont-ils numériquement
exploitables ? Justifiez vos réponses.
Exercice XXI
• Soit le vecteur float a[15] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14};  
Définissez un pointeur L de type float pointant vers le 8ème élément de a.
• Que vaut alors L[0] ?
• Que vaut alors L[4] ?
• Que vaut alors *(L-5) ?
• Donnez la syntaxe de déclaration de variables structurées en vous aidant d’un exemple complet
(déclaration de type incluse).

• Donnez la syntaxe générale de déclaration des fonctions, celle des prototypes, expliquez leur rôle.
• Précisez les endroits où il est possible de déclarer des variables, donnez leur portée dans chacun des cas.
• A quoi correspondent les paramètres d’une fonction ?
• Qu’entend-t-on par “passage par adresse ?”
Exercice XXII
• Déclarez un type de variable susceptible de contenir 53 entiers.
• Déclarez une variable du type créé précédemment.
• À la déclaration, initialisez toute les éléments de la variable créée à zéro
• En utilisant le type défini au premier point, déclarez une matrice M de 10 colonnes par 53 lignes.
• Que contient l'élément M[10][48] ?
• Définissez une chaîne de caractères S pouvant contenir 16 caractères.
• En utilisant la fonction sprintf entrez la chaîne “Il est beau Coco” (espaces compris) dans la variable S.
• Affichez la longueur de la chaîne de caractères par deux méthodes différentes.
Exercice XXIII
! 3(x) = x 3 − 4x + 2 que l’on a tracé sommairement
On se propose de déterminer les racines du polynôme P
ci-dessous. Donnez les racines avec une précision de 10-3 en utilisant la méthode de Newton. Pour chaque
racine, choisissez une valeur de départ arrondie à 0,5 près. Pour chaque racine vous justifierez le choix du
point de départ.
15
10
-5
-10
! -3 -2 -1 0 1 2 3
Exercice XXIV
! (x) = x 3 + x 2 − 14x − 24. On se propose de déterminer toutes ses racines à l'aide de la
Soit le polynôme P
méthode de Bairstow.
• Déterminez les valeurs de S et P vers lesquelles converge la méthode de Bairstow pour le polynôme P(x) si
l'on prend S0 = 1, P0 = -7. Donnez l'expression du polynôme quotient.
• Déterminez l'expression du polynôme quotient Q(x) et du reste R(x) tel que l'on ait :
! (x) = (x 2 − 2x + 8)Q(x) + R(x).
P
• À l'aide des deux premières questions et du schéma de Horner, exprimez P(x) sous la forme :  
! (x) = (x − α1)(x − α2 )(x − α3). Donnez alors toutes les racines de P(x).
P
Exercice XXV
2,5
On se propose d'évaluer l’intégrale I! = ∫0 F (X )d X. F(X) est connue par ses valeurs :
X 0 0,5 1 1,5 2 2,5
Y -1 -0,9 0 4 15 38
• Peut-on calculez la valeur de l'intégrale par la méthode de Simpson ?

• Montrez qu'il est possible de calculer la valeur de l'intégrale I en combinant les méthodes des Trapèzes et
de Simpson. Donnez les 3 solutions permettant d'utiliser la méthode de Simpson sur l'étendue la plus
large possible
• Donnez les 3 approximations de l'intégrale I en utilisant chacune des 3 solutions proposées ci-dessus.
Quelle est la meilleure approximation selon vous ? Justifiez votre réponse.
Exercice XXVI
Soit P(x) = x5 - 3x4 -5x3 + 15x2 + 4x -12.
• Ce polynôme a deux racines évidentes. Trouvez-les, puis, à partir de ces racines, déterminez S et P tel que
l'on ait :  
P(x) = ( x2 - Sx + P )Q1(x).
• Déterminez les coefficients de Q1(x) par la méthode de Bairstow.
• Déterminez les racines de Q1(x) par la méthode de Bairstow en prenant d'abord {S=2, P=1}, puis {S=1,
P=1}. Donnez tous les coefficients du polynôme quotient Q2(x).
• Calculez alors toutes les racines de P(x) et écrivez P(x) sous forme factorisée.
Exercice XXVII
• Soit le support numérique :
xi -4 -2 0 2 4
yi=F(xi) 6 -6 -10 -6 6
• Quel est, a priori, le degré du polynôme d’interpolation passant par ces points ?
• Calculez la valeur en x=1 que prend le polynôme d’interpolation déterminé par la méthode de Newton.
• On sait par ailleurs que F(1) = -9. Comparez cette valeur avec celle que vous avez trouvé.  
Quelle conjecture pouvez-vous faire quant à la nature de la fonction F ?  
Aviez-vous une autre raison pour émettre cette hypothèse ?
• En supposant les conditions requises vérifiées, calculez à l’aide du tableau des différences la valeur de la
fonction  
F(x) en x = 6.
Exercice XXVIII
X 0 1 2 3
Y=F(X) 3 4 7 12
• F(X) est une fonction polynomiale. A l'aide du tableau des différences déterminez son degré.
• Déterminez la valeur de tous les coefficients de la forme canonique croissante du polynôme
d’interpolation exprimé en variable réduite u.
• En remplaçant la variable réduite par son expression, déterminez l'expression du polynôme
d'interpolation. On donnera la valeur de tous les coefficients de sa forme canonique décroissante.
Exercice XXIX
En utilisant la méthode de Taylor à l'ordre 2, résolvez l'équation différentielle y'=x*y.
• Donnez la relation permettant de calculer yk+1 à partir de yk , xk et h.
• En utilisant les conditions initiales x0=0, y(x0)=0 et un pas d'intégration h égal à 1, calculez la valeur de y(4).
Exercice XXX
En utilisant la méthode de Taylor à l'ordre 2, résolvez l'équation différentielle y'=3x-1.
• Donnez la relation permettant de calculer yk+1 à partir de yk , xk et h.

Exercice XXXI
En utilisant la méthode d'Euler corrigée, déterminez y(0,2) sachant que le fonction y vérifie l'équation
dy 2
différentielle : ! =1− x .
dx 2
• On pendra comme conditions initiales y(0)=0 et un pas d'intégration égal à 0,1. La précision de l'affinage
sera pris égal à 10-3. A chaque calcul on calculera la solution Euler, puis l'affinage.
• Justifiez le fait que l'affinage ne comportera ici qu'un seul calcul, et ce quelque soit la précision attendue.
Exercice XXII
En utilisant la méthode d'Euler corrigée, déterminez y(1) sachant que le fonction y(x) vérifie l'équation
dy
différentielle : ! = 1 − y 2.
dx
• On pendra comme conditions initiales y(0)=1 et un pas d'intégration égal à 1. La précision de l'affinage
sera pris égal à 10-3. A chaque calcul on calculera la solution Euler, puis l'affinage.
• Même question mais avec un pas d'intégration égal à 0,5.
En utilisant la méthode de Taylor à l'ordre 2, calculez y(1) en prenant les mêmes conditions qu'au point 1.
• Que pouvez-vous conjecturer quand à la solution de cette équation différentielle avec ces conditions
initiales ?

Université Paul Sabatier Techniques Scientifiques Numériques L2 EEA/Méca/GC
A. Méthode de Bairstow
A.i. Introduction
Cette méthode qui date des années 1970 n'est adaptée qu'à la détermination des racines de fonctions
polynomiales. Elle est lente et coûteuse en temps de calcul, mais à l'avantage de “marcher”
systématiquement ou presque. Elle permet, de plus, de déterminer toutes les racines qu'elles soient réelles ou
non.
La méthode est basée sur la division du polynôme par un trinôme : T (x) = x2 Sx + P
On écrit : P (x) = (x2 Sx + P )Qn 2 (x) + R(x)
L'idée est de rechercher, non pas les racines de P(x), mais les valeurs de S et P qui annulent R(x), le reste, qui
est un polynôme du premier degré.
En effet, si S et P annulent R(x) alors si α est racine de T(x), par suite, il est aussi racine de P(x).
Pourquoi S et P ?
T(x) = x2-Sx+P = (x-α)(x-β) est un trinôme il accepte deux racines α et β qui vérifient :
S= +⇥
! P = ⇥
A.ii. La méthode
On se donne S0 et P0 arbitraires, on calcule le reste R(x) puis on ajuste S et P en S1, P1 jusqu'à ce que l'on ait
M ax(|Sn+1 Sn |, |Pn+1 Pn |) < la précision souhaitée.
On retient alors Sn+1 et Pn+1 comme valeurs approchées de S et P.
Posons :
P (x) = a0 xn + a1 xn 1
+ a2 xn 2
+ · · · + an 1x + an
Q(x) = b0 xn 2
+ b1 xn 3
+ b2 xn 4
+ · · · + bn 3x + bn 2
!
R(x) = R0 x + R1
En identifiant P(x) à T(x)*Q(x)+R(x) et ce quelque soit x, on obtient un système d'équations qui ne peut
avoir de solution que si les termes de puissance égale sont égaux, c'est à dire que les coefficients du
polynôme sont les mêmes des deux cotés de l'égalité.
Méthode de Bairstow 15 P. Castelan

Soit en développant :
Puissance terme de P terme de T(x)Q(x) + R(x)
xn a0 b0
xn-1 a1 b1 - Sb0
xn-2 a2 b2 - Sb1 + Pb0
… … …
xn-k ak bk - Sbk-1 + Pbk-2
… … …
x2 an-2 bn-2 - Sbn-3 + Pbn-4
x an-1 R0 - Sbn-2 + Pbn-3
cste an R1 + Pbn-1
Ce qui nous intéresse est de calculer les coefficients bk il vient :
b0 = a0
b1 = a1 + Sb0
b2 = a2 + Sb1 - Pb0
…
bk = ak + Sbk-1 - Pbk-2
…
R0 = an-1 + Sbn-2 - Pbn-3
R1 = an - Pbn-1
Afin de garder la même relation de récurrence tout au long du calcul, on pose :
bn-1 = an-1 + Sbn-2 - Pbn-3
bn = an + Sbn-1 - Pbn-2
Avec cette convention, le reste R0x + R1 s'écrit : bn-1(x-S) + bn, soit R1 = bn - Sbn-1
Le reste de la division R(x) : bn-1(x-S) + bn est fonction de S et de P. On pose :
F(S,P) = bn-1 et G(S,P) = bn - Sbn-1
Si S et P sont les valeurs qui annulent R(x), alors on a simultanément :
F(S,P) = 0 et G(S,P) = 0
Afin de déterminer S et P, on utilise une méthode itérative dont le principe est le suivant :
On construit une suite Sn , Pn telle que :
lim Sn = S et lim Pn = P
n ⇥ n ⇥
Au rang n de la suite, on connaît Sn et Pn, il est donc possible d'écrire :
S = Sn + S et P = Pn + P
Où ∆S et ∆P sont respectivement l'erreur commise sur S et P au rang de la suite. On a donc :
0 = F (Sn + S, Pn + P)
0 = G(Sn + S, Pn + P)

Bien entendu ∆S et ∆P ne sont pas connus. La méthode consiste justement à essayer de les évaluer.
Exprimons F et G sous forme d'un développement limité que l'on tronque à l'ordre 1. Soit :
0 F (Sn , Pn ) + F
S S+ F
P P
0! G(Sn , Pn ) + G
S S+ G
P P
On réécrit les équations ci-dessus en les égalant à zéro. On commet, ce faisant, une erreur que l'on inclue
dans les valeurs de ∆S et ∆P. On note ces valeurs approchées : $ S et P . On peut, alors, écrire :
0 = F (Sn , Pn ) + F
S S+ F
P P
! 0 = G(Sn , Pn ) + S S+
G G
P P
Ce système d'équation peut être mis sous forme matricielle :
⇥⇤ ⌅ ⇥
F F ⇧S F (Sn , Pn )
S P = Soit : Ax = B
G G ⇧P G(Sn , Pn )
! S P
On peut, en utilisant la méthode de Cramer, déterminer $ S et P :

det(A1 ) det(A2 )
S= et P =
! det(A) det(A)
Avec :
⇥ ⇥
F (Sn , Pn ) F F
F (Sn , Pn )
det(A ) = det 1
et det(A ) = det P 2 S
! G(Sn , Pn ) G
P
G
S F (Sn , Pn )
Ce qui permet de calculer nouvelle valeur de S et de P :
$ n+1 = Sn +
S S et Pn+1 = Pn + P
Toutefois, nous n'avons pas les valeurs numériques des dérivées partielles... Il nous faut donc calculer les
F F G G
valeurs de : S , P S, P
bk F G
➡ Calcul de S ce qui permettra d'évaluer : S, S
b0
S = a0
S =0
b1
S = a1
S +S b0
S + b0 S
S = b0 ⇥ c0
b2
S = a2
S +S b1
S + b1 S
S P b0
S b0 P
S =S b1
S + b1 = b1 + Sc0 ⇥ c1
b3
S = a3
S +S b2
S + b2 S
S P b1
S b1 P
S =S b2
S + b2 P b1
S = b2 + Sc1 P c0 ⇥ c2
..
.
bk bk
bk
S = ak
S +S S
1
+ bk S
1 S P S
2
bk P
2 S = bk 1 + Sck 2 P ck 3 ⇥ ck 1
..
.
bn an bn bn
S
1
= S
1
+S S
2
+ bn S
2 S P S
3
bn P
3 S = bn 2 + Scn 3 P cn 4 ⇥ cn 2
bn bn
!
bn
S = an
S +S S
1
+ bn S
1 S P S
2
bn P
2 S = bn 1 + Scn 2 P cn 3 ⇥ cn 1

De manière générale, on constate qu'il s'agit d'appliquer une nouvelle division par T(x) et que l'on a :
bk
= ck 1
$ S
Comme G(S,P) = bn - Sbn-1 il vient :
G bn bn 1
= S bn 1 = cn 1 Scn 2 bn 1
$ S S S
bn
Afin d'éviter ce terme bn-1, on calcule le terme S
en lui retranchant le terme bn-1 soit :
bn
= Scn 2 P cn 3 ⇥ cn 1
$ S
Le terme bn-1 étant inclus déjà retranché on alors : G

S = cn 1 Scn 2 ce qui simplifiera les calculs
ultérieurs.
bk F G
➡ Calcul de P ce qui permet d'évaluer : P , P
b0
P = a0
P =0
b1
P = a1
P +S b0
P + b0 S
P =0
b2
P = a2
P +S b1
P + b1 S
P P b0
P b0 P
P = b0 ⇥ c0
b3
P = a3
P +S b2
P + b2 S
P P b1
P b1 P
P = Sc0 b1 ⇥ c1
b4
P = a4
P +S b3
P + b3 S
P P b2
P b2 P
P = Sc1 b 2 + P b0 ⇥ c2
..
.
bk bk
bk
P = ak
P +S P
1
+ bk S
1 P P P
2
bk P
2 P = bk 2 Sck 3 + P ck 4 ⇥ ck 2
..
.
bn an bn bn
P
1
= P
1
+S P
2
+ bn S
2 P P P
3
bn P
3 P = bn 3 Scn 4 + P cn 5 ⇥ cn 3
bn bn
!
bn
P = an
P +S P
1
+ bn S
1 P P P
2
bn P
2 P = bn 2 Scn 3 + P cn 4 ⇥ cn 2
On a donc :
bk
= ck 2
! P
D'où :
F bn 1 G bn bn 1 S
= = cn 3 et = S bn 1 = cn 2 + Scn 3
! P P P P P P
Le calcul des déterminant donne :
det(A1 ) = bn 1 cn 2 bn cn 3
det(A2 ) = bn 1 cn 1 bn cn 2
det(A)
! = cn 1 cn 3 c2n 2
Ce qui permet d'exprimer :
bn 1 cn 2 bn cn 3 bn 1 cn 1 bn cn 2
S= et P =
! cn 1 cn 3 c2n 2 cn 1 cn 3 c2n 2
➡ En résumé
3. On choisit arbitrairement des valeurs pour S et P.
4. On calcule les bk et les ck (attention ! il n'y a pas de cn et cn-1 est calculé sans bn-1)
5. On calcule $ S et P.
6. Si $ S et P sont suffisamment petits on arrête le processus, sinon on calcule les nouvelles

valeurs pour S et P : S = S + S et P = P + P et on reprend au point 2
7. On détermine les racines de T(x), ce qui donne deux racines de P(x)
➡ Remarque : la méthode est lourde en calculs et lente (50 itérations sont parfois nécessaires !) On choisit
donc une précision des calculs faibles, les racines étant affinées par d'autres méthodes.
➡ Le gros avantage est que cette méthode permet de trouver toutes les racines d’un polynôme qu’elles
soient réelles ou complexes.

Nombres Complexes : Calculs élémentaires
Soient : z 1=a jb et z 2=c  jd
Somme : z 1z 2=ac  j b d 
Différence : z 1 – z 2 =a−c  j b – d 
Produit : z 1∗z 2 =a∗c – b∗d  j a∗d b∗c 
Conjugué : z1 =a – jb
∣z 1∣=1 =  z 1∗ z1 =  a b
2 2
Module :
z 1 z 1∗z2 z 1∗z2 a∗c b∗d  j b∗c −a∗d 

Rapport : = = =
z 2 z 2∗z2 ∣z 2∣2 c 2 d 2
Angle :
Diagramme d'Argand
z =a jb
b α a= cos0 b
=atan ?
b =sin  0 a
a β
Arc tangente est à image dans [ − 
;
2 2 ]
L'angle α s'obtient en tenant compte des signes de a et b.
C'est ce que fait la fonction atan2 dont le prototype est :
double atan2(double y, double x);
j
Logarithme : z =a jb =e  log z =log j 
Rappels nombres Complexes 20 P. Castelan

TP 1 : Retour sur les fonctions

1. Rappels.
1.1. Fonctions
Une fonction est un bloc d'instruction que l'on peut appeler en lui transmettant des paramètres. Les
paramètres sont des variables locales à la fonction, c'est à dire qui n'existent que dans le bloc d'instructions
de la fonction, elles sont initialisées avec les valeurs transmises à l'appel.
Les fonctions ont un nom et un type. Le type peut être un des types simples, void ou un type de structure.
Dans le cas ou le type n'est pas void, la fonction comporte une instruction return.
L'instruction return est suivie d'une expression du même type que celui de la fonction.
type nom_de_fonction ( liste de variables paramètres )
{ ...
return expression ; // du type de la fonction
}
L'appel d'une fonction se fait avec son nom et en précisant la valeur de chacun de ses paramètres.
Toute fonction (sauf main) doit avoir un prototype. Les prototypes sont obligatoirement groupés en début
de programme après les directives de compilation et les déclarations de type. Ils sont constitués de la ligne
d'en tête de chacune des fonctions du programme suivit d'un point virgule.
1.2. Déclaration de types

Il est possible de déclarer des types à l'aide de l'instruction typedef. C'est une instruction, il y a donc un
point virgule en fin de ligne. Pour un type de variable dimensionné la syntaxe est :
typedef type_de_variable_simple Nom_du_nouveau_type[ nombre d_éléments ] ;
En général, on déclare des types globaux en début de programme après les directives de compilation et
avant les prototypes.
2. Exercice 1
★ Ecrivez une fonction qui calcule la valeur de la fonction !F (t) = 230 2si n(ωt) en un point t.
✦ Déterminez les paramètres d'entrée de la fonction.
✦ Donnez le type de variable retournée.
✦ Choisissez un nom de fonction, et écrivez-là ainsi que son prototype.
✦ À l'aide de la fonction écrite, calculez les valeurs prises par un signal de fréquence 50 Hz
durant une période sur 100 points. (Calculs dans la fonction main() )
★ Modifiez la fonction pour qu'elle retourne tous les points dans une variable dimensionnée.
Déterminez les paramètres de cette fonction ainsi que son type.
★ Créez un type de variable dimensionnée que vous appellerez datas. Modifiez la fonction précédente
pour qu'elle utilise en paramètre une variable de type datas.
3. Exercice 2
✦ Créez un type de variable appelé vect pouvant contenir dim éléments réels. dim est une
constante définie en directive de compilation.
✦ Ecrivez une fonction appelée saisie, qui saisisse les coordonnées d'un vecteur de dimension
dim. dim est-il un paramètre de la fonction ?
✦ Ecrivez une fonction appelée produit qui calcule le produit scalaire de deux vecteurs.
Déterminez quelles sont les paramètres nécessaires à cette fonction.
★ À l'aide de ces deux fonctions, saisissez deux vecteurs X et Y, puis calculez le produit scalaire de ces
deux vecteurs et affichez le résultat.
✦ Créez un type de variable appelé mat, permettant de stocker les éléments d'une matrice
composée d'une collection de dim vect.
Texte du TP 1 21 P. Castelan
✦ Ecrivez une fonction appelée extrait, qui extrait d'une matrice M la colonne k et la stocke dans
un vecteur V. Déterminez les paramètres de la fonction.
✦ Ecrivez une fonction affiche qui affiche sous forme matricielle une matrice à l'écran. Déterminez
les paramètres nécessaires à cette fonction.
★ À l'aide des fonctions produit et extrait, calculez le produit matriciel de deux matrices A et B dans la
fonction main. La saisie des deux matrices se fera à l'aide de la fonction saisie dans la fonction main.
★ Testez votre programme sur des matrices de rang 3 et des vecteurs de dimension 3.
4. Rappels produit scalaire / Produit matriciel

2
{−1
t! V = 3ex + 2ey − ez : V1 = {3 2 −1} et !V2 = 3ex + 2ey − ez : V1 =
1 1
t! V . V V1kV2 k où V k est la coordonnée k du vecteur V

∑
1 2 =
tV est un vecteur à gauche ou vecteur ligne, V2 est un vecteur à droite ou vecteur colonne. On note les
1
vecteurs ligne tV
Une matrice est un collection de vecteurs : M = [[V1 ] . . . [Vn ]]
2 3 2 3
1 2 3 1
Ainsi la matrice M = 4 5 6 7 5 est en fait le regroupement des trois vecteurs : V1 = 4 5 5,
9 4 3 9
3 2 2 3 22 32 32 33
2 3 1 2 3
V2 = 4 6 5, V3 = 4 7 5,soit M = 44 5 5 4 6 5 4 7 55
4 3 9 4 3
Mais la matrice M peut aussi être vue comme composée de vecteurs Ligne :
2 ⇥ ⇤ 3 2 t 3
⇥ 1 2 3 ⇤ U1
M =4 ⇥ 5 6 7 ⇤ 5 = 4 t U2 5
t
! 9 4 3 U3
Le produit matriciel est donc le produit des vecteurs ligne de la matrice à gauche par les vecteurs colonnes
de la matrice à droite :
3 2 t
U1
M.M = 4 t U2 5 . [[V1 ] [V2 ] [V3 ]]
t
!
U3
Il s'agit donc d'un ensemble de produits scalaires et l'élément ligne i, colonne j de la matrice résultat est en
fait le produit scalaire du vecteur t Ui .Vj
Exemple de résultat :
0 1 0 1 0 1
1 2 3 2 6 7 5 10 24
A = @ 5 6 7 A;B = @ 5 2 7 A ; A ⇤ B = @ 13 42 84 A
! 9 4 3 1 0 1 41 46 38  
TP 2 : les Pointeurs
1. Rappels.
1.1. Pointeurs simples
Un pointeur est une variable qui contient des adresses. Au même titre qu'une variable de type int contient
un entier, le contenu d'un pointeur est une adresse.
On déclare un pointeur en faisant précéder son nom d'un astérisque.
type *nom;
Les variables n'ayant pas toutes la même longueur les pointeurs sont typés. Ainsi, il y a des pointeurs sur des
int, des pointeurs sur des float etc.
Avec un pointeur il est possible d'afficher, de manipuler des adresses.
printf("%X", adresse) ; // affiche une adresse sous forme hexadécimale (base 16)
Il est possible d'ajouter des adresses. Si X est une adresse correspondant à une variable int, alors X+1 est
l'adresse du prochain int possible.
1.2. Variable pointée.

Si P est un pointeur, on appelle variable pointée, la variable dont l'adresse est contenue dans P.
Il est possible d'obtenir l'adresse de la variable pointée en utilisant le pointeur P : c'est son contenu
Il est possible d'obtenir le contenu de la variable pointée en utilisant le pointeur P, il suffit d'utiliser
l'opérateur d'indirection *. Le tableau ci-dessous résume l'utilisation d'un pointeur P déclaré comme suit :
int a, *P;
P = &a ; // P contient désormais l'adresse de la variable a.
Code Signification Exemple
P Utilise le contenu de P, c'est à dire l'adresse de a scanf("%d",P) ;
*P Utilise le contenu de la variable pointée par P, c'est à dire, ici, a. printf("a vaut : %d\n",*P);
1.3. Variables dimensionnées

Une variable dimensionnée est une collection de variables du même type, regroupées sous un même nom,
auxquelles on accède à l'aide d'un numéro appelé indice. On place cet indice entre crochets droits.
type nom[ nombre_d_éléments ] ; // déclare une variable appelée nom du type spécifié.
Le nom d'une variable dimensionnée est l'adresse du premier élément de cette variable. Il s'agit donc d'un
pointeur, mais il est impossible de modifier le lien nom = &nom[0]; contrairement aux pointeurs simples.
À l'aide de l'addition des adresses, il est possible de calculer l'adresse de l'élément k d'une variable
dimensionnée :
&nom[ k] <=> nom + k ;
Il est donc possible d'accéder au contenu de la variable d'indice k d'une variable dimensionnée à l'aide de
l'opérateur d'indirection.
nom[k] <=> *(nom + k)
La parenthèse est obligatoire, l'indirection est prioritaire sur l'addition.
2. Exercice 1
Tout ce qui suit doit être écrit dans la fonction main.
★ Créez deux variables de type float a, b, ainsi que deux pointeurs p1 et p2. Faites pointer p1 vers a,
p2 vers b.
A partir de maintenant vous n'accéderez plus aux variables a et b qu'à travers les pointeurs.
★ Entrez, à l'aide d'instructions scanf un contenu dans a et b.
★ Calculez b = b*a
★ Affichez le contenu de a et de b
★ Comparaison : si a est plus grand que b affichez "A est plus grand" ; "B est plus grand ou égal" sinon.
L'utilisation de pointeurs tel que vu dans cet exercice est possible. Toutefois, convenez-en, cela ne sert
à rien, autant utiliser a et b ! Cet exercice n'a d'autre but que de vous faire manipuler les syntaxes
pointeur.
3. Exercice 2
★ Ecrivez une fonction qui saisisse deux float à l'aide de pointeurs, le prototype sera
void saisie( float *a, float *b);
★ Ecrivez une fonction calcule le produit de deux float, et retourne le résultat à l'aide d'un pointeur. Le
prototype sera d'abord :
void calcul1 (float *a, float *b); // résultat dans b
puis
void calcul2 ( float a, float b, float *c); // résultat dans c
★ A l'aide des trois fonctions écrites ci dessus, depuis la fonction main, saisissez deux nombres réels,
puis calculez et affichez leur produit. Vous n'utiliserez que deux variables dans main. D'abord avec la
fonction calcul1, puis calcul 2.
4. Exercice 3
★ Dans la fonction main, déclarez une variable dimensionnée appelée X pouvant contenir 50 float.
★ Ecrivez une fonction appelée saisie. Elle demandera le nombre de points que l'utilisateur veut saisir,
puis procédera à la saisie des points. L'interface de la fonction sera
void saisie( float x[50], int *n);
✦ Saisissez les valeurs suivantes : { 5, 9, 4, -2 } à l'aide de saisie, puis affichez-les depuis la fonction
main.
★ Même question avec cette fois l'interface suivante pour la fonction saisie :
void saisie( float *x, int *n);
★ Créez un type de variable pouvant contenir 50 float appelé datas.
✦ Remplacez dans la fonction main, la déclaration de X par datas X; Lancez le programme sans
modifier la fonction saisie. Conclusion ?
✦ Modifiez le programme précédent pour que l'on saisisse 4 valeurs à partir de l'élément 9 (donc
dans X[9], X[10], X[11], X[12]). Affichez les 15 premiers éléments de x. Conclusion ?
★ Complétez le programme précédent en écrivant une fonction qui affiche à l'écran, les n dernières
valeurs en ordre inverse d'une variable dimensionnée ainsi que leur position, la fonction aura
l'interface suivante :
void affiche( float *P, int n);
Indication : Si l'on appelle la fonction ainsi : affiche( &X[10], 3), cela provoquera l'affichage suivant :
0 X[10] // comprendre par X[10] la valeur de cette variable.
-1 X[9] // idem etc.
-2 X[8]
-3 X[7]
★ A l'aide de ces fonctions, saisissez les 5 valeurs suivantes à partir de la position 7 de X : { 8, -2, 4, 0, 3 }.
Affichez alors ces valeurs dans l'ordre inverse de leur saisie à l'aide de la fonction affiche.
TP 3 : les Structures
1. Structures
Une structure est le regroupement de plusieurs variables pouvant être de types différents sous un même
nom, ces variables sont appelées champs.
Pour utiliser une variable structurée, il est préférable de créer un type. La syntaxe est :
typedef struct { type champ_1 ; type champ_2; … ; type champ_n ; } nom_du_type ;
Pour utiliser le type défini on crée des variables ou des pointeurs.
nom_du_type var1, var2, *var3;
L'accès aux différents champs des variables structurées se fait en indiquant précisant le champ à l'aide d'un
point.
var1.champ_1 ou var1.champ_2 etc.
S'il s'agit d'un pointeur vers une structure, on accède aux champs à l'aide de l'opérateur -> ou en utilisant
des parenthèses :
var3->champ_1 ou (*var3).champ_2
Il est possible d'affecter des structures entre elles, pour une fonction de retourner une structure.
var1 = var2; var2 = *var3; // affectation de structures
var1.champ_1=var2.champ_1; var2.champ_2 = var3->champ_2; // affectation de champs
nom_du_type MaFonction( ... ) ; // prototype d'une fonction retournant une structure
2. Exercice
L'objet est de définir les fonctions permettant de réaliser des calculs en complexe : addition, soustraction,
multiplication, conjugué, module, division, angle, logarithme.
★ Saisie / affichage de nombres complexes. Dans chaque cas vous déterminerez le type des fonctions
écrites ainsi que leurs paramètres d'entrée.
✦ Créez un type de variable structurée comportant deux champs re pour la partie réelle, im pour
la partie imaginaire.
✦ Ecrivez une fonction qui affiche un nombre complexe transmis en paramètre à l'écran sous la
forme a + ib. Les nombres seront affichés avec 4 décimales au minimum.
✦ Ecrivez une fonction qui réalise la saisie d'un nombre complexe et le retourne. La fonction devra
demander la partie réelle, puis la partie imaginaire successivement. Cette fonction a-t-elle
besoin d'un paramètre en entrée ?
✦ Testez votre programme en saisissant puis affichant un nombre complexe.
★ Ecrivez dans cet ordre les fonctions réalisant les opérations suivantes. Vous pouvez utiliser les
fonctions précédemment écrites. Respectez le nom de chacune des fonctions qui vous est proposé.
Déterminez pour chaque fonction le nombre de paramètres et le type de valeur retournée.
✦ Addition : C_add
✦ Soustraction : C_Sous
✦ Multiplication : C_mul
✦ Conjugué : C_conj
✦ Module : C_mod
✦ Division : C_div
✦ Angle : C_angle (regardez l'aide en ligne -fonction man- sur la fonction atan2)
✦ Logarithme Népérien : C_log
Testez vos fonctions avec des exemple connus (cf ci-après)
★ Modifiez la fonction saisie pour qu'elle soit de type void. (A TRAITER IMPERATIVEMENT)
3. Exemples de résultats
Entrez la partie reelle : 2
Entrez la partie imaginaire : 3
Entrez la partie reelle : -1
Entrez la partie imaginaire : 1
Addition :
1.0000 + i 4.0000
Soustraction :
3.0000 + i 2.0000
Multiplication :
-5.0000 + i -1.0000
Conjugue :
2.0000 + i -3.0000
Module :
3.6056
Division :
0.5000 + i -2.5000
Angle :
0.9828
Logarithme :
1.2825 + i 0.9828
TP 4 : Lecture de fichiers
1. Rappels de langage
Le programmeur n'accède pas directement aux fichiers, il demande au Système d'Exploitation de s'occuper
de toute la gestion technique : pilotage des disques durs etc.
Pour ce faire, il suffit de créer un pointeur de type FILE * (en majuscules !), puis de demander au SE de
créer un lien via ce pointeur. C'est le rôle de la fonction fopen. La lecture s'effectue à l'aide des fonctions
fscanf et fprintf.
Lorsqu'on écrit un fichier, le plus simple est de mettre l'écriture dans une boucle for, en effet on connaît
forcément le nombre d'éléments à écrire.
Par contre lors de la lecture, ce n'est pas le cas. Il faut alors être capable de savoir si l'on a atteint la fin du
fichier. La fonction feof donne cette information. Elle s'utilise le plus souvent avec une boucle de type "tant
que" : tant que ( la fin du fichier n'est pas atteinte )
Enfin, une fois la lecture ou l'écriture finie, il faut fermer le fichier à l'aide de l'instruction fclose.
La syntaxe exacte des fonctions sus-citées est :
fopen( "chemin d'accès au fichier","mode"); // retourne une adresse de type FILE *
Le type d'accès est soit "r" pour la lecture, soit "w" pour l'écriture. Le chemin d'accès utilise des "/" même
sous l'environnement Windows.
fprintf( variable_de_type_FILE, "chaine de format", liste de variables ) ;
fscanf( variable_de_type_FILE, "chaine de format", liste d'adresses de variables ) ;
feof( variable_de_type_FILE ) ;
fclose( variable_de_type_FILE) ;
2. Exercice
Dans ce qui suit, toutes les fonctions à écrire seront de type void.
Vous trouverez sur le bureau de votre poste de travail un fichier intitulé TP4.txt, si le fichier n'est pas
présent, demandez-le à l'enseignant.
Ce fichier est constitué de deux colonnes X et Y (dans cet ordre) de n réels séparées par un espace.
★ Lisez le contenu du fichier TP4.txt dans votre programme en faisant un écho (affichage) à l'écran.
✦ Ne connaissant pas la longueur du fichier, vous créerez un type de variable pouvant contenir
1000 float appelé datas.
✦ Ecrivez une fonction qui lise le fichier TP4.txt, et détermine le nombre de points lus.
Déterminez les paramètres d'entrée et de sortie de la fonction qui s'appellera lecture.
✦ A l'aide de cette fonction, lisez le contenu du fichier, puis dans la fonction main, affichez toutes
les valeurs lues.
Le signal lu est bruité, afin de diminuer ce bruit, on procédera de la façon suivante : chaque fois qu'un des Y
est supérieur à trois fois la moyenne du vecteur Y, on fixe la valeur de cet élément à zéro.
★ Filtrez le signal lu.
✦ Ecrivez une fonction appelée ecriture qui crée un fichier de type texte appelé filtre.txt et
y écrive deux colonnes de valeurs, séparées par une tabulation, transmises en paramètres à la
fonction. Déterminez les paramètres d'entrée et de sortie de la fonction.
✦ Créez une fonction qui calcule la valeur moyenne d'un vecteur. Cette fonction sera appelée
moyenne vous déterminerez les paramètres d'entrée et de sortie.
✦ Calculez, dans la fonction principale la valeur moyenne des ordonnées lues (vecteur Y), puis
appliquez l'algorithme décrit ci-dessus.
✦ Sauvegardez dans un fichier portant le nom filtre.txt les données ainsi traitées. Le fichier
contiendra les vecteurs X et Y séparés par un espace.
★ Lancez le logiciel Octave, puis dans la fenêtre qui s'ouvre tapez les commandes suivantes :
cd Desktop
M = load -ascii filtre.txt ;
x = M( : , 1 ) ;
y = M( : , 2 ) ;
plot(x,y)
Une fenêtre graphique devrait s'ouvrir contenant la courbe des points que vous avez filtré.
★ On peut améliorer le filtrage en modifiant la procédure utilisée en utilisant un filtrage en deux étapes.
On procède comme précédemment, si Yi est supérieur à trois fois la valeur moyenne de Y, alors on
impose Yi à zéro, en même temps, dans un vecteur auxiliaire Z, préalablement initialisé à zéro, on
impose Zi à un. Dans une deuxième phase, si Zi vaut 1 alors on remplace Yi par la moyenne des
deux points environnants.
Signal non filtré Signal filtré (mise à zéro) Signal Filtré (deux passes)
2
250
200
1.5
150
100
0.5
50
0 0
!
0 2 4 6 8 10 0 2 4 6 8 10
! !
TP 5 : Dérivées de polynôme
1.Méthode de Horner :
Référez-vous au cours pour plus de détails sur la méthode d'Hörner.
Il est possible de calculer la valeur d'un polynôme et de sa dérivée à l'aide de la méthode suivante dite
méthode de Horner.
Coefs de Pn (x) Calcul de Pn (a) Calcul de Pn0 (a)
a0 b0 = a0 c0 = b0
a1 b1 = b0 a + a1 c1 = c0 ⇤ a + b1
.. .. ..
. . .
ai bi = bi 1 a + ai ci = ci 1 ⇤ a + bi
.. .. ..
. . .
Pn0 (a)
an 1 bn 1 = bn 2 a + an 1 cn 1 = cn 2 ⇤ a + bn 1 = 1!
!
an bn = bn 1 a + an = Pn (a)
Pour calculer la dérivée en un point α donné, il suffit d'enchaîner deux schémas de Horner successifs.
2.Travail à effectuer :
Ecrire un programme qui :
➡ Effectue la saisie des coefficients d'un polynôme de degré inférieur ou égal à 9 et de son degré. La
saisie sera recommencée tant que l'utilisateur n'aura pas saisi un degré compris dans l'intervalle[1 ; 9].
➡ Saisisse la valeur d'un point de départ x0 ainsi qu'un pas h pour calculer la valeur du polynôme et de
sa dérivée sur 26 points régulièrement espacés depuis le point de départ x0.
➡ Cherche dans les valeurs calculées une racine du polynôme et affiche la valeur de la dérivée en ce
point. Dans le cas où il n'y aurait pas de racine le programme affichera le message : "pas de racine
trouvée".
Pour ce faire, vous écrirez les fonctions et définitions de type suivantes. Les commentaires C expliquent le
rôle de chaque variable.
typedef float vect[10];
typedef float pts[26];
void Horner( float *pa , int pn , float pal, float *pP, float *pb);
/* pa pointe vers le vecteur des coefs de P_n(x)
* pn est le degre de P_n(x)
* pal le point de calcul
* pP pointe vers une variable qui contiendra P_n(al)
* pb pointe vers un vecteur qui contiendra les b_i
*/
void saisie(float *pa , int *pn);

/* Saisie des coefs d'un polynome P_n(x)
* pa pointe vers le vecteur qui contiendra les coefs de P_n(x)
* pn pointe vers une variable qui contiendra le degre P_n(x)
* La saisie sera refusée tant que n est >9
*/
3.Plan de travail
★ Calcul des valeurs prises par le polynôme :
✦ Ecrivez la fonction saisie. Testez-la en affichant dans la fonction main les coefficients d'un
polynôme saisi. Vérifiez que vous ne pouvez entrer un degré > 9, ni < 1.
✦ Ecrivez la fonction Horner. Testez-la avec le polynôme suivant en α = 2 : Pn(x) = x2 + x -3
Vous devez trouver :
Coefs de P2(x) calcul de P2(2)
1 b0 = 1
1 b1 = 1*2+1 = 3
-3 b2 = 3*2 -3 = 3 = P2(2)
✦ Ecrivez le code nécessaire pour réaliser la saisie de x0 le point de départ et de h le pas. Ces
saisies se feront dans la fonction main.
✦ À partir de x0 et en utilisant le pas h, calculez 26 points équidistants. À l'aide de la fonction
Horner, calculez les valeurs prises par le polynôme saisi avec la fonction saisie et calculez la
valeur de la dérivée en ces points. Vous afficherez le résultat des calculs sous la forme de
colonnes contenant les valeurs correspondant aux intitulés suivants :
n° du point : xi Pn(xi) P'n(xi)
Exemple avec P3(x) = x3 + x2 - 10x + 8, point de départ x0 = -1 pas : h = 0,1
0 : -1.000 18.000 -9.000
1 : -0.900 17.081 -9.370
2 : -0.800 16.128 -9.680
3 : -0.700 15.147 -9.930
…
★ Dans la fonction main écrivez le code nécessaire pour trouver les points dont la valeur absolue1 de
l'ordonnée est inférieure à 10-5. Affichez alors le message suivant :
"Racine au point <indice du point> soit x= <abscisse correspondante> 
et P'(x) = <valeur de la dérivée>"
Exemple d'exécution du programme avec le même polynôme que ci-dessus :
Saisie des coefs du polynome :
Entrez le degre de P_n(x) : 3

Entrez le coef de x^3 : 1
Entrez le coef de x^1 : -10
Entrez le point de depart :-1

Entrez le pas :0.1
0 : -1.000 18.000 -9.000

1 : -0.900 17.081 -9.370
2 : -0.800 16.128 -9.680
3 : -0.700 15.147 -9.930
4 : -0.600 14.144 -10.120
5 : -0.500 13.125 -10.250
6 : -0.400 12.096 -10.320
7 : -0.300 11.063 -10.330
8 : -0.200 10.032 -10.280
9 : -0.100 9.009 -10.170
10 : 0.000 8.000 -10.000
11 : 0.100 7.011 -9.770
12 : 0.200 6.048 -9.480
13 : 0.300 5.117 -9.130
14 : 0.400 4.224 -8.720
15 : 0.500 3.375 -8.250
16 : 0.600 2.576 -7.720
17 : 0.700 1.833 -7.130
18 : 0.800 1.152 -6.480
19 : 0.900 0.539 -5.770
20 : 1.000 0.000 -5.000
21 : 1.100 -0.459 -4.170
22 : 1.200 -0.832 -3.280
23 : 1.300 -1.113 -2.330
24 : 1.400 -1.296 -1.320
25 : 1.500 -1.375 -0.250
Racine au point 20 soit x=1.000000
et P'(x) = -5.000000 
1 La fonction pour calculer la valeur absolue d'un float est fabs. Son prototype est dans math.h
TP 6 : Interpolation : Méthode de Lagrange

1. La méthode
Une fonction F(x) est connue par les valeurs qu'elle prend en n+1 points {x,y}, on cherche à déterminer pour
un α donné appartenant à [xmin, xmax] la valeur y = F(α) sans connaître l'expression de F(x). Cette fonction  
F(x) peut être représentée par un polynôme Pn(x) de degré n passant par ces n+1 points {x,y}. Une méthode
pour déterminer Pn(x) est la méthode de Lagrange :
n
Φ(x) n x − xj
∑ ∏
P
! n(x) = Lk (x)yk où Lk (x) = =
k=0
(x − xk )Φ(xk ) j=0, j≠k xk − xj
Les Li(x), appelés coefficients de Lagrange, sont des polynômes de degré n. Le calcul de Pn(α) se est mené
de la manière suivante :
1/ Calcul des coefficients de Lagrange Li(α).
2/ Calcul de la somme des produits Li(α)*yi.
2. Travail à effectuer
Vous écrirez une fonction qui, à partir des pivots Px et Py, calculera la valeur du polynôme d'interpolation en
un point α en utilisant la méthode de Lagrange. Cette fonction aura le prototype suivant :
float lag(vect Px, vect Py, int pn, float palfa );
vect est un type de variable que vous créerez pouvant contenir 10 float.
★ Mise au point du programme
✦ Ecrivez la fonction lag
✦ Testez-la 2 avec l'exemple vu en Travaux Dirigés, vous devez trouver -11,205.
★ Vérification que le polynôme d'interpolation passe par les pivots
✦ Modifiez la fonction horner écrite lors du TP précédent pour qu'elle retourne un float
contenant la valeur calculée du polynôme. Collez-là dans votre programme.
✦ Dans la fonction main, générez un vecteur PivX, dans une variable de type vect contenant cinq
valeurs régulièrement espacées entre -2 et 2
✦ Calculez en utilisant la méthode d'Horner les valeurs PivY prises par le polynôme P3 donné ci-
après. on donne : !P (x) = 5x 3 − 8x 2 + 2x + 3
✦ Calculez et affichez la valeur prise par le polynôme d'interpolation d'une part et d'autre part le
polynôme P(x) calculé avec la méthode d'Horner sur 20 points régulièrement espacés dans
l'intervalle [-2 ; 2]. Affichez les valeurs sous forme de deux colonnes.
✦ Que constatez-vous ? Pouviez-vous prédire ce résultat ? 
Point 1 : -39.785 -39.785
Interpolation du TD : -11.205391 -27.530 -27.530
...
Point 2 : 3.128 3.128
P(x) Interpolation 2.991 2.991
-73.000 -73.000 2.566 2.566
-54.848 -54.848 2.130 2.130 
1.966 1.966
2.352 2.352
3.569 3.569
5.895 5.895
9.613 9.613
15.000 15.000 
2 Il n'est pas demandé de saisie ici, les variables dimensionnées seront initialisées lors de leur déclaration.
3 La saisie des coefficients de P n'est pas demandée, P sera initialisé à la déclaration.

Projet : Recherche de points particuliers par

interpolation
1. Objectif
Les objectifs de ce projet sont multiples :
• Approfondir la maîtrise de la programmation en langage C : pointeurs, fichiers, mémoire dynamique.
• S'approprier les outils vus en technique scientifique : Lagrange, Horner…
• Découvrir les limites des méthodes, trouver des techniques pour contourner ces difficultés.
• Mettre en œuvre une démarche raisonnée consistant à construire des outils numérique, les valider puis les
évaluer en critiquant les résultats obtenus pour améliorer les outils et obtenir, in fine, le résultat souhaité.
Pour ce faire, ce projet va vous conduire à résoudre un problème que tout scientifique est amené à résoudre
régulièrement : compléter un relevé expérimental composé de n+1 points {x ! k , yk } avec k! 2 [0; n]. Pour
simplifier la suite de l'exposé, on appelle F, la fonction reliant les abscisses aux ordonnées : !yk = F (xk )
Le problème choisi sera de déterminer avec précision la plus haute valeur d'une courbe : déterminer
l'abscisse d'un maximum local (ou sommet). Cela implique d'être à même de calculer des points entre ceux
que comporte le relevé expérimental. La détermination de ces ordonnées n'est pas compliquée si l'on
connait la fonction F(x). Bien entendu, cette fonction n'est pas connue, et l'on remplace localement la
fonction F(x) par le polynôme d'interpolation.
Deux approches seront utilisées : la dichotomie et la recherche de la racine de F'(x).
1.i. Dichotomie.
Cette approche utilise un algorithme dérivé de celui de la dichotomie.
L'idée est de déplacer une fenêtre de largeur α : [ xk - α ; xk + α ] en diminuant la largeur α cette fenêtre
lorsque le maximum se trouve dans cette fenêtre en suivant l'algorithme de la dichotomie. Le plus simple est
une illustration pour comprendre cet algorithme.
18
17 x2
x1
16
15
x0
14
2*
13
12
2 4 6 8 10 12
!
Fig. 1 : méthode de dichotomie, phase d'approche de la zone du sommet entre deux phases de dichotomie
L'algorithme est le suivant. On calcule F (xk ↵), F (xk ) et F (xk + ↵).
Si la plus grande des trois valeur est F (xk ↵) on calcule xk+1 = xk .
Si la plus grande des trois valeurs est F (xk + ↵) on calcule xk+1 = xk +
Si la plus grande des trois valeurs est F (xk ) on divise ↵ par 2.
On recommence le processus tant que > 2⇥ , la précision souhaitée.
Cette méthode est simple à programmer, c'est celle que vous réaliserez en premier.
Mini-Projet 32 P. Castelan
1.ii. Racine de la dérivée

Cette méthode utilise le fait qu'en un maximum local, la dérivée d'une fonction s'annule (cf. cours de maths
L1-Semestre 2).
La difficulté de cette seconde approche est qu'il va falloir chercher la racine de la fonction F'(x) dans
l'intervalle [a, b], or F(x) n'est pas connue. Aussi c'est la racine de la dérivée du polynôme d'interpolation
dans l'intervalle [a, b] qui sera déterminée.
25
Points experimentaux
Interpolation
20
Derivee
15
10
-5
-10
2 4 6 8 10 12
!
Fig. 2 : Points expérimentaux et polynôme d'interpolation. Noter la zone d'interpolation. La dérivée est
calculée à partir du polynôme d'interpolation. Noter qu'elle a deux racines dont une, hors de la zone
d'interpolation, est à rejeter.
Pour déterminer les valeurs prises par la dérivée du polynôme d'interpolation, nous faisons le choix d'utiliser
la méthode d'Horner, il nous faut donc l'expression littérale du polynôme d'interpolation. Dans ce cas
n
∏
l'expression du polynôme d'interpolation à utiliser fait appel à Φ(x)
! = (x − xk ).
k=0
Il faut donc être capable de calculer (x), la méthode de Leverrier-Newton permet ce calcul. Cette
méthode est décrite plus loin.
Φ(x)
Une fois que (x) est connu, il faut calculer les coefficients de Lagrange : Lk (x) =
(x − xk )Φ′(xk )
Les Lk(x) sont le résultat de la division de (x) par (x-xk), ce que l'on peut réaliser à l'aide d'un schéma de
0
Horner, puis par (xk ), que l'on peut calculer à l'aide d'un second schéma de Horner.
Pn
Une fois les Lk(x) calculés on peut calculer P (x) = k=1 Lk (x)Yk
La racine de F'(x), donc de P(x) sera déterminée par la méthode de Newton.
En résumé pour cette seconde méthode, nous aurons besoin de savoir :
• Déterminer l'expression du polynôme d'interpolation par la méthode de Lagrange, ce qui impose de
savoir :
• calculer (x) à l'aide de la méthode de Leverrier-Newton (cf ci-dessous)
• savoir calculer les Lk(x).
• Calculer la dérivée de ce polynôme d'interpolation : méthode d'Horner.
• Déterminer la racine de la dérivée de ce polynôme : méthode de Newton.
Pour chacun de ces points le plus simple est d'écrire une fonction dédiée.
2. Rappels
2.i. Gestion dynamique de la mémoire.

Pour gérer dynamiquement la mémoire et créer des variables dimensionnées, on utilisera la fonction malloc.
Par exemple pour créer une variable dimensionnée, a une dimension de 10 éléments, de façon statique on
déclare :
int a[10] ;
ou
typedef int vect[10]
…
vect a;
De manière dynamique :
int *p;
p = (int *) malloc( 10*sizeof( int ) );
// pointeur = ( transtypage type du pointeur) malloc( nombre*sizeof( type éléments ))
Pour des variables a une dimension, cela est donc simple. Il suffit de ne pas oublier de libérer la mémoire en
fin de programme.
Pour des variables a deux dimensions, cela est plus complexe (encore que...)
Avec un typedef, on conseille de procéder en deux étapes :
typedef int vect[10];
typedef vect mat[10];
…
mat a;
Dans ce cas, a[3] est un vect, c'est à aussi un pointeur… puisque c'est le nom d'une variable dimensionnée.
Le type de a[3] est donc int *. Par conséquent, le type de a est int **.
Dans le cas d'une variable dimensionnée, on peut créer une variable à deux dimensions4 de la manière
suivante :
int **p;
p = ( int **) malloc ( Nligne*sizeof( int *) );
// chaque ligne est une variable dimensionnée de type int *, p est de type int **;
Puis pour chaque ligne k :
p[k] = ( int *) malloc( ncolone*sizeof( int ) );
// p[k] est de type int *, p[k][l] est de type int
Notez qu'il est alors possible d'avoir des variables dimensionnées ayant un nombre de colonnes différent
pour chaque ligne…
2.ii. Polynôme d'interpolation : Méthode de Newton

Soient n+1points {x,y}, régulièrement espacés d'un pas h :
x0 x0 + h … x0 + i*h … x0 + n*h
y0=f(x0) y1=f(x1) … yi=F(xi) … yn=F(xn)
On cherche à déterminer pour un α donné {α ∈ [ x0, x0+n*h]} la valeur de y = f(α) sans connaître l'expression
de f(x). Cette fonction f(x) peut être représentée par un polynôme Pn(x) de degré n passant par les n+1
0 u 1 u (u − 1) 2 u (u − 1)…(u − (n − 1)) n
points {x,y}. Pn(α) s'écrit : Pn (u) = Δy0 + Δy0 + Δy0 + … + Δy0
1! 2! n!
x − x0
où u est la variable réduite : u! =
h
0 0 i i−1 i−1
et les Δy
! k sont les différences finies construites avec les relations : Δy
! k = yk et Δyk = Δ yk+1 − Δ yk
2.iii. Racine d'une fonction : Méthode de Newton.

Le développement en série limitée (DL) de Taylor d'une fonction f(x) s'écrit :
(x − x 0 ) 2
f! (x)x 0 = f (x 0 ) + (x − x 0 )f ′(x 0 ) + 2!
f ′′(x 0 ) + …
Si calcule un DL en xn, au point xn+h tel que xn+h = α une racine de f(x) et en tronquant ce DL à l'ordre 1 :
f! (xn + h) = f (xn ) + ((xn + h) − xn )f ′(xn ) + O ((xn + h) − xn )2 = f (x − N ) + h f ′(xn ) + O (h)2
4 On se reportera avec profit au cours du mercredi 7 avril dernier.

f (x n )
Or α est racine de f(x), donc f(α) = f(xn+h) = 0. Il vient en négligeant O(h)2 : h ≈ −
f ′(x n )
Ou, en intégrant l'erreur commise dans h, que l'on note alors !h, il vient :!h ̂ = −
b f (x n )
. On calcule alors non
f ′(x n )
f (x n )
pas la valeur d'α, mais une nouvelle valeur de xn que l'on notre xn+1 : x n+1 = x n − qui est une
f ′(x n )
meilleure approximation d'α.
2.iv. Méthode de Leverrier-Newton

Cette méthode permet de calculer l'expression de la forme canonique d'un polynôme à partir de la
connaissance de sa forme factorisée. Un même polynôme peut en effet s'écrire :
n
Y1
P (x) = a0 xn + a1 xn 1 + · · · + an 1 x + an = (x x0 )(x x1 ) · · · (x xn 1 ) = (x xk )
! k=0
Notez bien qu'un polynôme de degré n, a n+1 coefficients et n racines numérotées, ici, de 0 à n-1.
n−1
xj
∑ k
La méthode consiste à calculer un vecteur contenant la somme des puissances des racines : S! j =
k=0
A partir de ce vecteur, on calcule les coefficients du polynôme sous sa forme canonique en appliquant
l'algorithme suivant :
a0 = 1
a 0 S1 + 1.a1 = 0
a S + a1S1 + 2.a 2 = 0
! 0 2
a 0 S3 + a1S2 + a 2 S1 + 3.a3 = 0
⋮
a 0 Sn + a1Sn−1 + … + a n−1S1 + n . a n = 0
On pose a0=1 par convention.

Il suffit de calculer a0, pour pouvoir calculer a1, puis a2 etc. La fonction peut ainsi s'écrire :
void Leverrier(double *X, int n, double *a)
{ int i,j;
double *S,p; // p auxiliaire de calcul pour le calcul des puissances
/* n est le nombre de racines */
S = (double *) malloc( (n+1)*sizeof(double) );
// Attention il y a n éléments de S1 à Sn, donc n+1 éléments de 0 à n.
/* Calcul des Sommes de puissances */

for (i=0 ; i<n ; i++) /* Il y n racines... */
{ p = X[i];
for (j=1 ; j<=n ; j++) /* On ne calcule pas S[0], début à 1... */
{ S[j] = S[j]+p;
p = p*X[i]; /* p = puissances successives X[i] */
}
}
/* remontee de la solution */
a[0]= 1;
for (i=1 ; i<=n ; i++) /* Pn(x) a n+1 coefs */
{ a[i] = 0;
for ( j=0 ; j<=i-1 ; j++ )
{ a[i] = a[i] - a[j]*S[i-j];
}
a[i] = a[i]/i;
}
free(S);
}
Notez dans ce code l'usage fait de malloc, et surtout l'utilisation d'un variable p pour calculer les puissances
successives. Noter de même l'utilisation de S[i-j] pour croiser les indices. En effet dans l'expression
1
permettant de calculer le terme ak : ak = − (a 0 Sk + a1Sk−1 + a 2 Sk−2 + … + ak−1S1)
n
On remarque que les indices des termes de la somme sont croisés, ainsi, le terme j de la somme est le
produit de aj*Sk-j
Vous recopierez cette fonction telle quelle dans votre programme pour déterminer le polynôme Φ(x)
!
3. Travail à effectuer
➡ Remarque générale : toutes les variables dimensionnées seront crées à l'aide de pointeurs et en
utilisant la gestion dynamique de la mémoire. Le fichier de données contient 10 points.
➡ Attention ! : La méthode de Leverrier amène à calculer la somme des abscisses jusqu'à la puissance 10
(il y a 10 points). Par conséquent, il n'est pas possible d'utiliser des variables en simple précision (float).  
C'est pourquoi toutes les fonctions utiliseront des variables de type double précision.  
Dans ce cas, le type de champs à utiliser dans les saisies (scanf, fscanf) et les sorties (printf, fprintf) est %lf
(la lettre 'L' et non le chiffre 1) et non %f.
3.i. Lecture du fichier

Avant toute choses, il faut bien entendu lire les points contenus dans un fichier appelé : projet_L2.txt, pour
ce faire :
★ Ecrivez une fonction qui lise le contenu du fichier projet_L2.txt. L'interface est laissée libre.
3.ii. Calcul du polynôme d'interpolation : méthode de Newton

Ensuite, il faut être capable d'évaluer le polynôme d'interpolation.
★ Ecrivez une fonction qui calcule la valeur en un point quelconque la valeur prise par le polynôme
d'interpolation calculé par la méthode de Newton. L'interface de cette fonction sera :
double newton_poly(double *Delta, int n, double u); 
/* *Delta pointe vers une variable dimensionnée contenant les différences finies  
* en y0, n est le nombre de différences, et u le point de calcul exprimé en variable
* réduite. 
*/
0 1 2 3 4
✦ Testez votre fonction avec les différences pour Y0 : Y0 = 1, Y0 = 3, Y0 = 14, Y0 = 36, Y0 = 24
vous devez trouver : P(3) = 88 et P(3,5) ≈ 158,06
★ Ecrivez une fonction qui calcule la valeur de la variable réduite :
double varred(double xo, double h, double x)
/* Calcule la valeur de la variable réduite u au point x. x0 et h ont leur sens
* habituels
*/
✦ Testez votre fonction.
★ Ecrivez une fonction qui calcule toutes les différences finies au point Y0 :
void diffinies( double *y, int n, double *d);
/* *y pointe sur une variable dimensionnée contenant les Yi
* n est le nombre de points du vecteur pointé par *y, et *d pointe
* vers une variable contenant en sortie de fonction les différences finies en y0.
*/
✦ Testez votre fonction avec le vecteur Y suivant : Y = {1, 4, 21, 88, 265} vous devez trouver les
différences finies en y0 données deux point au dessus.
★ A l'aide de ces trois fonctions, calculez la valeur prise par le polynôme d'interpolation lorsqu'on
interpole les points suivants :
X -2 -1 0 1 2
Y -2 3 2 1 6
✦ Vous devez trouver P(1.5) = 2,375.
3.iii. Méthode Dichotomie.

Pour cette méthode nous allons écrire une fonction dédiée. Cette fonction aura comme paramètres d'entrée
les pivots (points lus) et leur nombre, le point de départ de la méthode, et la largeur de la fenêtre au départ.
★ Ecrivez une fonction appelée dichotomie qui mette en œuvre l'algorithme proposé au point 1.i. Le
prototype de la fonction sera :
double dichotomie( double *px, double *py, int n, double alpha, double x );
/* px et py pointent vers les points, n est le nombre de points utilisés pour
* l'interpolation. Alpha est le paramètre décrit au § 1.1, la largeur de la
* fenêtre. x est le point de départ de l'algorithme.

*/
➡ Remarque 1 : Cette fonction dichotomie lancera le calcul des différences finies afin de déterminer le
polynôme d'interpolation qui sera utilisé pour déterminer les valeurs de la fonction F(x).
➡ Remarque 2 : Il n'est pas utile d'interpoler sur les 10 points du fichier (cf la figure 2) On transmettra au
pointeurs px et py les adresses des premiers points de la zone d'interpolation. De même la valeur
transmise pour n sera le nombre de points utilisés pour l'interpolation. Afin de permettre à l'utilisateur de
facilement choisir ces valeurs, les points lus seront affichés dans la fonction main().
➡ Remarque 3 : La précision des calculs sera de 1e-5, elle sera codée directement dans le programme.
★ Testez cette fonction avec plusieurs valeurs d'α { 2, 1, 0.5…}, la largeur de l'intervalle et en prenant
comme point de départ le deuxième point lu. Affichez à l'écran les valeurs successives trouvées pour x
et les valeurs d'α dans la boucle de calcul. Que constatez-vous ?
Afin de corriger ce problème l'algorithme est complété comme suivant :
x2=x1;
x1=x0;
it++;
if (it>1)
{ if (x0 == x2)
{ alpha = alpha/2;
it = 0;
}
}
★ Expliquez la signification de chaque variable, sachant qu'x0 est la valeur calculée dans la boucle en
cours. Expliquez le rôle de la variable it, et des variables x1 et x2 au cours des boucles de la méthode
mise en œuvre.
Exemple d'exécution du programme :
PhiL:Projet phil$ ./a.out
*** Points lus ***

0 2.000000 12.416590
1 3.000000 12.846458
2 4.000000 13.992534
3 5.000000 15.515667
4 6.000000 16.593288
5 7.000000 17.432881
6 8.000000 17.338295
7 9.000000 15.952573
8 10.000000 14.150546
9 11.000000 12.754494
Entrez l'indice du point de départ : 3

Entrez la valeur de départ d'Alpha : 1
Nombre de pts pour l'interpolation : 5
Valeur trouvée : 7.431915
★ Faites un bilan de cette méthode. Est-elle pleinement satisfaisante ?
3.iv. Méthode racine de la dérivée.

★ Pour cette méthode il faut déterminer l'expression du polynôme d'interpolation (exercice demandé à
préparer en TD). Pour cette méthode, il faut tout d'abord déterminer à l'aide de la fonction Leverrier
(cf 2.iv) l'expression de (x). On utilisera npi pivots pour déterminer un polynôme autour d'une zone
et non sur l'ensemble des pivots (comme pour la méthode de Dichotomie).
✦ Insérez la fonction Leverrier permettant de déterminer les coefficients de Φ(x) dans votre
programme :
void Leverrier(double *X, int n, double *a)
/* X est un pointeur vers les racines de la forme factorisée du polynôme Φ(x)
* n est le nombre de racines (ici ce sera 10...) et a un pointeur vers une variable
* qui contiendra les coefficients du polynôme Φ(x). Attention, s'il y a n racines
* alors Φ(x) est de degré n, il a donc n+1 coefficients !!
*/
✦ Testez la fonction avec les points suivants : x0=1, x1=2, x2=3, Vous devez obtenir le polynôme de
degré 3 (avec 4 coefficients donc) : P(x) = x3 - 6x2 + 11x - 6.
★ Ecrivez une fonction permettant le calcul du reste et des coefficients du polynôme quotient de P(x)/(x-
α). Le prototype de cette fonction sera le suivant :
double horner( double *a, double *b, int n, double alfa );
/* a : coefs du polynôme, b : coefs du polynome quotient, n : degre de a
* alpha, point de calcul
*/
★ Ecrivez une fonction servant à déterminer l'expression littérale du polynôme d'interpolation. Cette
fonction utilisera la fonction horner pour calculer chaque coefficient de Lagrange.
void detpoly( double *X, double *Y, int n, double *a)
/* X est un pointeur vers les abscisses et Y vers les ordonnées des points
* pour lesquels on cherche à déterminer l'expression du polynôme d'interpolation
* n est le nombre de points, et a un pointeur vers une zone mémoire suffisante pour
* contenir les coefficients d'un polynôme de degré n-1.
*/
★ Dans la fonction principale, calculez la valeur des coefficients du polynôme dérivé. On rappelle que
l'on a (ak xn )0 = n ⇤ ak xn 1.
★ Ecrivez une fonction qui, en utilisant la méthode de Newton et la méthode d'Horner, détermine une
racine d'un polynôme à partir d'un point de départ x0. Le prototype de cette fonction sera :
double Newton( double *a, int n, double x0 );
/* a = coefs du polynôme, n degre du polynôme, x0 : point de départ de la méthode
* La précision des calculs sera de 1e-6 en précision relative et non absolue.
*/
★ En utilisant le polynôme dérivé, et la fonction Newton, déterminez une valeur approché de l'abscisse
du sommet.
➡ Exemple de calcul :
Entrez l'indice du point de départ : 3

Nombre de points pour l'interpolation : 5 *** Polynôme derivé ****
*** Points Interpolés **** x^4 0.014133 *4 -> 0.056532
0 Py = 12.416590 22.904047 x^3 -0.483485 *3 -> -1.450455
1 Py = 12.846458 17.126913 x^2 5.516838 *2 -> 11.033675
2 Py = 13.992534 15.235363 x^1 -25.093760 *1 -> -25.093760
3 Py = 15.515667 15.515668 x^0 54.665967 *0 -> 0.000000
4 Py = 16.593288 16.593288 Valeur Interpolation : 7.431922
5 Py = 17.432881 17.432881
6 Py = 17.338295 17.338295
7 Py = 15.952573 15.952573
8 Py = 14.150546 13.257953
9 Py = 12.754494 9.575864
Entrez le point de départ : 7
3.v. Bilan
Quelle est d'après-vous la méthode la plus efficace ? Pouvait-on envisager d'autres méthodes ? 
«Contrat de confiance TP»

Sujets types d'un sujet d’examen (composé d’1 ou 2 sujets)
Contrairement aux TD, les sujets d'examen s'inspireront de ces exercices type, mais seront forcément
légèrement différents…
Sujet 1
Vous trouverez, un fichier de type texte (exo1.txt) constitué de 4 colonnes comportant chacune le même
nombre d’éléments.
1. La première, des données diverses détaillées ci-dessous.
2. La deuxième, des abscisses de point.
3. La troisième, les ordonnées d’une fonction, f(x), relative aux abscisses de la colonne 2.
4. La quatrième, les ordonnées d’une autre fonction, g(x), relative aux abscisses de la colonne 2.
5. La première colonne comporte dans l’ordre :
Alpha_1.
Alpha_2.
L’indice du dernier élément de chaque colonne, ce qui vous permettra de confirmer le nombre de
points lus.
Valeur théorique de f(Alpha_1).
Valeur théorique de f(Alpha_2).
Valeur théorique de g(Alpha_1).
Valeur théorique de g(Alpha_2).
Ces quatre dernières données serviront à calculer l’erreur relative commise par le polynôme d'interpolation.
• Définissez le type points : typedef float points[Nmax], Nmax est entier et vaut 10.
• Ecrivez un programme comportant obligatoirement 2 fonctions dont les prototypes seront :
void lire(points data, points x, points y1, points y2, int *n);
La fonction lire() permet de lire les données du fichier exo1.txt et de les stocker
respectivement dans les variables data, x, y1 et y2. Le nombre d’éléments par
colonne est retourné via le pointeur *n.
float lagrange(float al, points x, points y, int n );

La fonction lagrange() calcule la valeur du polynôme d’interpolation passant par les
pivots x, y en un point al. n est l'indice du dernier pivot.
Aucune valeur ne doit être saisie au clavier, toutes les valeurs sont issues du fichier exo1.txt.
• Dans la fonction main() calculez l'erreur (en pour cent) commise par le polynôme d'interpolation pour les
fonctions f(x) et g(x) en Alpha_1 et Alpha_2.
• Modifiez votre programme pour qu'il utilise des variables dynamiques à la place des variables de type
points. La dimension des variables à créer peut être déterminée par une première lecture du fichier
servant à déterminer le nombre d'éléments.
Sujet 2
Le but du programme est de déterminer la racine d'une fonction F connue par ses points par la méthode de
la dichotomie.
• Définissez un type « vect » de 20 éléments réels.
• Ecrivez une fonction « lire » qui a le prototype suivant :
void lire (vect x, vect y, int *n)
Les vecteurs x et y contiennent respectivement le abscisses et les ordonnées de la
fonction F (y = F(x)). Ces données sont contenues dans le fichier « exo2.txt » sous
forme de deux colonnes séparées par un « ; ». Les points sont échantillonnés
régulièrement. La fonction doit retourner le nombre de points à l'aide du pointeur
n.
• Ecrivez une fonction « lag» qui a le prototype suivant :
float lag (vect x, vect y, int n, float al)
Contrat de Confiance TP 39 P. Castelan

Cette fonction a pour rôle de calculer et de retourner au programme appelant la

valeur prise par le polynôme d'interpolation passant par les n+1 {xi, yi} au point
al. Le polynôme sera calculé par la méthode de Lagrange.
• Dans le programme principal, appelez la fonction lag en lui transmettant pour pivots les points du fichier
exo2.txt et al = -1,5. ( Vous devez obtenir ≈ -9.375 )
• Dans le programme principal déterminez la racine de la fonction y=F(x) par la méthode de dichotomie. La
fonction F sera évaluée à l'aide du polynôme d'interpolation
• Affichez à l'écran la valeur trouvée.
vect. La dimension des variables à créer peut être déterminée par une première lecture du fichier servant
à déterminer le nombre d'éléments.
Sujet 3
Le but du programme est de calculer la puissance moyenne dissipée dans un dipôle Z sur une période d’un
signal alternatif sinusoïdal et de déterminer le facteur de puissance.
• Définissez un type « vect » de 128 éléments réels.
• Ecrivez une fonction « lire » qui a le prototype suivant :
int lire (vect t, vect i, vect u)
Les vecteurs t, i et u contiennent respectivement le temps, le courant et la tension
aux bornes de Z. Ces données sont contenues dans le fichier « exo3.txt » sous forme
de colonnes séparées par un « ; » pour une période du signal. Les points sont
échantillonnés régulièrement. La fonction doit retourner le nombre de points.
• Dans la fonction main( ), calculez la puissance instantanée et affichez-la à l’écran avec le temps sur deux
colonnes. Note : P(t) = V(t)*I(t)…
• Ecrivez une fonction « trapeze » qui a le prototype suivant :
float trapeze (vect y, int n, float pas)
Cette fonction a pour rôle de calculer et de retourner au programme principal le
résultat de l’intégrale d’une fonction « y » échantillonnée sur « n+1 » points à
l’aide de la méthode des trapèzes.
Dans le programme principal :
• Déterminez h, le pas d’échantillonnage du signal à intégrer.
• Calculez la puissance moyenne sur 1 période du signal.
• Affichez le résultat à l'écran.
Sujet 4
Votre programme devra lire le fichier de type texte "exo4.txt". La première ligne de ce fichier contient un
nombre entier N. À partir de la deuxième ligne et sur N lignes le fichier comporte deux colonnes de
nombres réels séparées par une tabulation.
• Ecrivez une fonction lire qui aura obligatoirement le prototype suivant :
void lire( float *x, float *y, int *n);
• Lors de la lecture du fichier, la fonction devra afficher à l'écran les valeurs lues sous forme de colonnes.
• Définissez en début de programme un nouveau type de variable qui s'appellera obligatoirement vect et
qui pourra contenir 100 nombres réels.
• Dans la fonction main, procédez à la lecture du fichier "exo4.txt" à l'aide de la fonction lire, puis
déterminez l'indice à partir duquel les éléments de la seconde colonne (les "y") changent de signe.
• Affichez l'écran la valeur k de l'indice, les valeurs x(k) et y(k) correspondantes.
On cherche à déterminer α la racine de la fonction y(x) = exp(x) - 4*sin(x) par la méthode de Newton.
• Ecrivez une fonction Equa_h qui calcule la valeur de h en un x donné, h sera calculé à l'aide de la
méthode de Newton. L'interface sera obligatoirement :

float Equa_h(float x)
• Déterminez la valeur d'α avec une précision meilleure que 10-6 en implémentant dans votre programme la
méthode de Newton. Vous prendrez comme valeur de départ la valeur x(k) trouvée ci-dessus et utiliserez
obligatoirement la fonction Equa_h. Affichez cette valeur à l'écran avec un message indiquant de quoi il
s'agit.
Indication : la fonction pour calculer la valeur absolue d'un float est fabs() qui est dans math.h
Sujet 5
Votre programme devra lire le fichier de type texte nommé "exo5.txt". La première ligne de ce fichier
contient un nombre entier N. À partir de la deuxième ligne le fichier comporte ensuite N nombres réels.
void lire( float *x, int *n);
• Lors de la lecture du fichier, la fonction devra afficher à l'écran les valeurs lues sous forme de colonne.
• À l'aide de la fonction lire, stockez dans une variable x de type vect les points du fichier exo5.txt.
• Calculez, dans un vecteur S, la valeur prise par la fonction S(x) = sin(x) en chaque point du vecteur x. Pour
ce faire, vous écrirez une fonction appelée fonction qui retournera les valeurs de S(x) en chaque point du
vecteur x. L'interface de cette fonction sera :
void fonction(float *x, float *S, int n)
Indication : Il vous faudra inclure la bibliothèque math.h
P (x)
• Ecrivez une fonction qui calcule les coefficients du polynôme quotient Q(x) = x par la méthode
d'Horner. Le prototype de la fonction devra obligatoirement être le suivant :

void horn(float *P, float *Q, int n, float al)
/* Notation pour la fonction : P(x) = Q(x)(x-al) */
• À l'aide de cette fonction, calculez dans la fonction main la valeur de la dérivée du polynôme
x6 x4 x2
P (x) = + + 1 sur tous les points du vecteur x.
720 24 2
• Vous afficherez à l'écran sous la forme de 4 colonnes, séparées par une tabulation, les nombres avec 3
décimales (si applicable). Ces colonnes contiendront le numéro du point k, la valeur de x(k), la valeur de
S(k) = sin(x(k)) et P'(x(k)).
• En comparant les valeurs trouvées entre S(k) et P'(x(k)), quelle hypothèse peut-on émettre quand à P(x) ?
Sujet 6
Votre programme devra lire le fichier de type texte nommé "exo6.txt". La première ligne de ce fichier
contient un nombre entier N. À partir de la deuxième ligne le fichier comporte ensuite des nombres réels. N
est le numéro du dernier point du fichier dans une numérotation débutant à zéro.
void lire( float *t, int *n);
• Lors de la lecture du fichier, la fonction devra afficher à l'écran les valeurs lues sous forme de colonne.
• À l'aide de la fonction lire, stockez dans une variable t de type vect les points du fichier exo6.txt.

Calculez, dans un vecteur V, la valeur prise par la fonction V

! (t ) = 230 2c o s (100π t ) en chaque point du
vecteur t.
Indication : Il vous faudra inclure la bibliothèque math.h
• Pour ce faire, vous écrirez une fonction appelée tension qui retournera les valeurs de V(t) en chaque point
du vecteur t. L'interface de cette fonction sera :
void tension(float *V, float *t, int n)
On cherche à calculer la valeur moyenne et la valeur efficace du signal V(t). On rappelle que :
1 t 0 +T 1 t 0 +T
! moyen =
V ∫ V (t )d t et Vef f icace = ∫ (V (t ))2 d t
T t0 T t0
• Dans la fonction main, en utilisant la méthode de Simpson, calculez et affichez les valeurs moyennes et
efficace du signal V(t). Votre programme devra calculer la valeur h du pas et de la période T.
• Affichez à l'écran les valeurs moyennes et efficaces de V(t) au dos de la copie. Justifiez numériquement les
valeurs trouvées. Proposez une solution pour améliorer les résultats.
Sujet 7
• Déclarez un type vect pouvant contenir 20 variables de type float.
• Ecrivez une fonction lecture_poly, qui lira le fichier "exo7.txt". Ce fichier est composé d'une seule
colonne. La première ligne (1 élément) du fichier est un entier n qui est le degré d'un polynôme Pn(x). Les
autres données sont les coefficients de ce polynôme P(x). Le fichier est composé comme suit :
n
a0
!a1
⋮
an
Le prototype de la fonction lecture_poly doit être le suivant :
void lecture_poly(int *N, vect A)
Nota Bene : Vous utiliserez obligatoirement une boucle for pour la lecture du fichier.
• Ecrivez une fonction qui effectue le calcul de la valeur d'un polynôme par la méthode d'Horner. Son
interface sera :
void horner( int n, float al, vect a, vect b)
/* n est un entier qui contient le degré du polynôme
* al est un flottant qui contient la valeur du point où est calculé le polynôme
* a est un vecteur contenant les coefficients du polynôme calculé
* b est un vecteur contenant polynôme quotient. */
• Vous écrirez une fonction qui détermine une approximation de la racine de l'équation polynomiale Pn(x) =
0 par la méthode de Newton avec une précision meilleure que 10-4. La valeur de Pn(x) et de sa dérivée
seront calculés en utilisant la méthode de Horner. L'interface sera :
void newton( int n, vect a, float *x0)
/* n est un entier qui contient le degré du polynôme
* *x0 est un flottant qui contient la valeur du point de départ
* puis l'approximation de la racine, a est un vecteur contenant
* les coefficients de Pn(x). */
Nota Bene : la valeur absolue d'une expression d'un type float se calcule avec la fonction fabs() dont la
définition se trouve dans la bibliothèque math.h.
• Effectuez la lecture du polynôme et de son degré à l'aide de la fonction lecture_poly.
• Calculez, en utilisant la fonction Newton. la valeur d'une racine de P(x) en prenant comme point de départ
x0=1. Affichez cette racine.

Sujet 8
Le but du programme est de calculer la valeur moyenne Vmoy d’un signal sinusoïdal à l’aide de la méthode
des trapèzes, sur un intervalle de temps T.
• Ecrivez une fonction appelée ech qui aura le prototype suivant :
void ech (vect t, int n, float T);
Cette fonction doit échantillonner l’intervalle de temps T sur n+1 points
régulièrement espacés. Ces échantillons seront stockés dans le vecteur temps t.
• Ecrivez une fonction appelée stock qui permette d’écrire deux vecteurs de n+1 éléments sur deux
colonnes séparées par un point virgule dans un fichier qui s'appellera obligatoirement donnees.txt. Le
prototype de la fonction sera :
void stock (vect t, vect y, int n);
Afin de tester ces deux fonctions :
• Définissez une constante pi de valeur 3.1415927f.
• Définissez un type vect pouvant contenir 128 éléments réels.
• À l’aide des fonctions ech et stock vous écrirez dans le fichier donnees.txt les (n+1) valeurs de t et de
y(t) = ( 2+2sin(ωt)) régulièrement espacées sur une période d'un signal de fréquence 10Hz.
• Ecrivez une fonction appelée trapeze qui aura le prototype suivant :
void trapeze (vect y, int n, float h, float *integ) ;
Cette fonction a pour rôle de calculer et de retourner au programme principal le
résultat de l’intégrale d’une fonction échantillonnée à pas constant sur n+1 points
à l’aide de la méthode des trapèzes. Le résultat est retourné à l'aide du pointeur
integ, n est le numéro du dernier point contenu dans le vecteur y et h est le pas.
• Calculer la valeur moyenne de [2 + 2 sin(ωt)] sur 1 période du signal. Affichez le résultat à l'écran.
1 t2
t2 − t1 ∫t
Rappels : Valeur moyenne d’un signal V(t) entre deux instants t1 et t2 : V
! moy = V (t )d t
1
Sujet 9
On considère l’ensemble de données suivant : ( [ Xmin ; Xmax ] avec un pas h unitaire )
Xi -4 -3 -2 -1 0 1 2 3 4
• Calculez à l’aide d’une fonction Horner, que vous écrirez, la valeur prise, sur ces points, par le polynôme
! 5(x) = x 5 − 3x 4 + 2x 2 − 13
P
• Calculez sur ces mêmes points la valeur de la dérivée de P5(x) en utilisant la méthode d’Horner.
• Sauvegardez ces valeurs dans un fichier texte qui comportera trois colonnes séparées par un point virgule
(";"). La première colonne contiendra les abscisses, la deuxième les valeurs de P5(x), la troisième la valeur
de la dérivée de P5(x).
• Modifiez votre programme pour qu'il utilise des variables dynamiques et non des variables
dimensionnées statiquement. La dimension des variables à créer sera calculée en demandant la saisie du
nombre de points, de Xmin et Xmax. h sera calculé.
Sujet 10
Dans ce qui suit, N est le numéro du dernier point. Les autres variables ont leur sens évident.
On se propose de calculer la surface sous la courbe connue par des points stockés dans le fichier exo10.txt.
Ce fichier de deux colonnes séparées par des tabulations contient les données suivantes.
X Y
0 2
1 -1
4 2
5 27
• Définissez une type de variable appelé vect pouvant contenir 10 entiers.

• Ecrivez une fonction lecture qui lise le contenu du fichier exo10.txt. L'interface de la fonction devra être :
void lecture ( int *N , vect X , vect Y )
En utilisant la méthode d'interpolation de Lagrange, calculez les points manquants à savoir 2 et 3 en
utilisant les points lus à la question ci-dessus.
• Vous écrirez une fonction Lagrange qui devra avoir l'interface suivante.
float lagrange (int N , vect X , vect Y, float alfa)
/* X et Y sont les pivots, alfa le point de calcul */
Vous prendrez soin de classer les valeurs par abscisse croissante lors du calcul des ordonnées.
Nota Bene : Vous n'avez pas à écrire de fonction de tri !
Indication : Que vaut le polynôme d'interpolation sur un de ses pivots ?
• Ecrivez une fonction trapèzes qui devra avoir l'interface suivante :
void trapezes(int N , vect Y , float h, float *I)
/* Y un vecteur contenant les ordonnées, h le pas,
* I sert à retourner la valeur approchée de l'intégrale */
• Calculez une approximation de la surface en utilisant la méthode des trapèzes. Affichez à l'écran la valeur
calculée.
à déterminer le nombre d'éléments. Pensez à re-dimensionner les variables quand nécessaire.
Sujet 11
On se propose de résoudre numériquement l'équation différentielle y' = x+y = ƒ(x,y) par la méthode d'Euler
corrigée.
Vous procéderez pour ce faire comme suit.
• Définissez une fonction appelé F, de type float, ayant deux paramètres de même type x et y, qui retourne
la valeur de ƒ(x,y). Le prototype de la fonction sera : float F( float x, float y)
L'équation différentielle sera intégrée entre xmin et xmax à l'aide d'un pas d'intégration h.
• Dans la fonction main, procédez à la saisie des variables xmin, xmax, h. Calculez alors n le nombre de
points qu'il y a entre xmin et xmax si l'on parcours cet intervalle avec un pas h.
• En utilisant la fonction malloc, dimensionnez deux variables pouvant contenir n variables de type float
appelées x et y. Saisissez la condition initiale y[0]. On imposera x[0] = xmin.
• Dans la fonction main et en utilisant la méthode d'Euler non corrigée, calculez les solutions de l'équation
différentielles y'=ƒ(x,y) à l'aide des variables x, y, et de la fonction F(x,y). Toutes les solutions seront
conservées dans la variable y.
• Dans la fonction main, affichez toutes les solutions calculées sous forme de colonnes en suivant l'exemple
ci-dessous :
Solutions Euler :
X[0] : 0.000000 0.000000
X[1] : 0.100000 0.000000
X[2] : 0.200000 0.010000
X[3] : 0.300000 0.031000
• Ecrivez une fonction appelée affinage ayant le prototype suivant :
void affinage( float h, float *x0, float *y0, float *y1)
Cette fonction a comme paramètres d'entrée le pas d'intégration h, deux pointeurs sur les coordonnées des
conditions initiales {x0, y0}, un pointeur y1 sur la solution au point x1 = x0+h.
La méthode mise en œuvre dans cette fonction est l'affinage par intégration de l'équation différentielle par
la méthode des Trapèzes.
La méthode itérative sera répétée tant que la précision des calculs sera inférieure à 10-6.
• Complétez la méthode d'Euler dans la fonction main de façon à mettre en œuvre la méthode d'Euler
corrigée en utilisant la fonction affinage.
• Affichez alors dans la fonction main les solutions trouvées avec la méthode affinée.

Nota Bene : votre programme devra afficher successivement les solutions non affinées puis les solution
affinées. Pensez à utiliser le copier/coller.
x1 h
∫x
On rappelle que : y! 1 = y0 + f (x , y)d x = y0 + [F (x1, y1 − F (x 0, y0 )] ≈ y0 + [ f (x1, y1) + f (x 0, y0 )]
2
0
• Testez votre programme avec h=0,01, xmin = 0, xmax = 0,3, vous devez trouver y(0,3) ≈ 0,49862
• Sauvegardez les données calculées par la méthode d'Euler corrigée dans un fichier de type texte appelé
sortie.txt contenant deux colonnes séparées par une tabulation. La première colonne contiendra les
abscisses x[k] et la seconde les ordonnées calculées y[k].

Cahier - Complet - Technique Scientifiques 2019 - 01 PDF

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

Cahier - Complet - Technique Scientifiques 2019 - 01 PDF

Transféré par

Droits d'auteur :

Formats disponibles

!

Cahier de Techniques Scientifiques

De manière générale, il est fortement conseillé de venir en TD avec une calculatrice

Exercice 2 : Division polynomiale

Exercice 3 : Dérivées d'un polynôme

Exercice 4 : Calcul des dérivées successives

Exercice 6 : Lagrange : Méthode du Tableau

Exercice 7 : Lagrange : Avec ϕ(x)

Travaux Dirigés 3 P. Castelan

1. Calculer Φ(x), écrivez-le sous forme canonique.

Exercice 10 : Newton : Utilisation du tableau des différences

Exercice 11 : Programme interpolation de Newton - Travail personnel, cf. le projet de TP.

Exercice 12 : Recherche de racines : la méthode de Newton

Exercice 13 : Recherche de racines par Newton

Exercice 14 : Méthodes de Newton : les limites de la méthode.

Travaux Dirigés 4 P. Castelan

Exercice 16 : Bairstow, vitesse de convergence

Exercice 17 : Bairstow : choix du point de départ

Exercice 18 : Bairstow : programme C

Exercice 19 : Méthode de Dichotomie

Exercice 20 : Limites de la méthode de dichotomie

Exercice 21 : Dichotomie : programme (se référer au cours…)

Exercice 24 : Intégration : précision des méthodes.

Exercice 25 : Intégration : précision des méthodes.

Travaux Dirigés 5 P. Castelan

Exercice 26 : Intégration programme C

Exercice 27 : Dérivation numérique avec une fenêtre de 4 points.

Exercice 28 : Dérivation numérique avec une fenêtre à 4 points d'un polynôme.

Exercice 29 : Dérivation numérique programme C (Travail personnel)

Exercice 31 : Equation différentielle un peu moins simple, méthode de Taylor.

Exercice 32 : Equation différentielle simple, méthode Runge-Kutta

Exercice 33 : Equation différentielle un peu moins simple, méthode de Runge-Kutta.

Exercice 34 : Equations différentielle : RK2 programme C.

Travaux Dirigés 6 P. Castelan

Exercice 35 : Equation différentielle simple, méthode d'Euler

Exercice 36 : Méthode d'Euler itérative (ou corrigée)

Travaux Dirigés 7 P. Castelan

Contrat de Confiance 8 P. Castelan

Contrat de Confiance 9 P. Castelan

Contrat de Confiance 10 P. Castelan

Contrat de Confiance 11 P. Castelan

Contrat de Confiance 12 P. Castelan

Contrat de Confiance 13 P. Castelan

Contrat de Confiance 14 P. Castelan

Méthode de Bairstow 15 P. Castelan

Méthode de Bairstow 16 P. Castelan

On peut, en utilisant la méthode de Cramer, déterminer $ S et P :

Méthode de Bairstow 17 P. Castelan

Le terme bn-1 étant inclus déjà retranché on alors : G

6. Si $ S et P sont suffisamment petits on arrête le processus, sinon on calcule les nouvelles

Méthode de Bairstow 19 P. Castelan

Nombres Complexes : Calculs élémentaires

Soient : z 1=a jb et z 2=c  jd

Somme : z 1z 2=ac  j b d 

Produit : z 1∗z 2 =a∗c – b∗d  j a∗d b∗c 

z 1 z 1∗z2 z 1∗z2 a∗c b∗d  j b∗c −a∗d 

Rappels nombres Complexes 20 P. Castelan

TP 1 : Retour sur les fonctions

1.2. Déclaration de types

4. Rappels produit scalaire / Produit matriciel

t! V . V V1kV2 k où V k est la coordonnée k du vecteur V

1.2. Variable pointée.

1.3. Variables dimensionnées

void saisie(float pa , int pn);

* Points lus *