Ministère de l’Enseignement Supérieur

Cycles préparatoires
Des études d’ingénieur
Deuxième année

NOTES DE COURS DE MAPLE

TRAVAUX PRATIQUES
D’INFORMATIQUE
avec exercices corrigés

Janvier 2005

________________________________________________________________________ 1
 SOMMAIRE
Séance Eléments de contenu
Séance 1 Notes de cours, complément d’exercices,…..
Séance 2 Fonctions réelles à 1 seule variable
Domaine de définition
Continuité
Dérivées
Primitives et intégrales
Asymptotes
Courbe des fonctions
Exercices d'application
Séance 3 Fonctions réelles à 2 variables et développement limités
Domaine de définition
Dérivées partielles
Courbes
Développements limités
Exercices d'application
Séance 4 Polynômes et fractions rationnelles à une et plusieurs variables
Factorisation
Simplification
Développement
Tri
Arrangement
Substitution
Exercices d'application
Nombre complexe
Définition
Formes cartésienne et polaire
Evaluation dans C
Nombre conjugué, argument, module
Séance 5 Résolution des équations à variables complexes
Exercices d'application
Fonctions complexes
Domaine de définition
Images, zéros et points fixes d'une fonction complexe
Transformation géométrique dans le plan complexe
Exercices d'application
Séance 6 Algèbre linéaire : utilisation des fonctions prédéfinies Maple et programmation
Calcul matriciel
Déclaration des matrices et des vecteurs
Opérations sur les matrices: addition, multiplication par un scalaire et produit de deux matrices
Inverse, Puissance
Valeurs propres et Vecteurs propres
Trace, Noyau, Déterminant
Exercices d'application
Séance 7 Algèbre linéaire : utilisation des fonctions prédéfinies Maple et programmation (suite)
Polynômes caractéristiques
Résolution de système
Exercices d'application

Séance 8 Suites numériques

Calcul d'un terme quelconque
Somme des termes
Produit des termes
Suites récurrentes
Convergence
Exercices d'application
Séance 9 Equations différentielles
Rapport général sur les équations différentielles premier et second ordre

________________________________________________________________________ 2
 Exercices d'application
Systèmes différentiels
Exemple de solution
Exercices d'application
Séance 10 Révision générale : résolution de problèmes et leur programmation
Remarque : ces problèmes peuvent être choisis parmi les exercices et problèmes proposés dans le paragraphe
complément d’exercices du support « NOTE DE COURS DE MAPLE TRAVAUX PRATIQUES avec exercices
corrigés » ou autres.
Séance 11 Révision générale : résolution de problèmes et leur programmation (suite)

Séance 12 Application aux systèmes linéaires : électrocinétique

(*) Exemple en mathématique ou Exemple en physique
Calcul des réseaux maillés courant continu
Méthode simple (solve)
Par le calcul matriciel (linsolve) ou autres,…
Séance 13 Pendule simple
(*)
il est recommandé de réaliser des applications dans les domaines de la physique, chimie et
(*)
mécanique; sinon ces applications seront remplacées par des applications en mathématique. .

N.B. La charge horaire annuelle est de 26 heures.

________________________________________________________________________ 3
 Séance 1 [1]
Notes de cours et complément d’exercices
La programmation en MAPLE nécessite la connaissance de quelques notions de base. Outre les premières
fonctionnalités de MAPLE, déjà acquises par les étudiants et rappelées par l’enseignant , nous présentons à travers ces
brèves notes de cours le minimum d’outils de programmation à retenir. Ces rappels renferment trois parties sous forme
de paragraphes. Le paragraphe 1 contient les fonctions d’entrées sorties. Le paragraphe 2 s’intéresse aux structures de
contrôle ( if simple et en alternative, les boucles et ses variétés). Les fonctions et les procédures font l’objet du
paragraphe 3. Au paragraphe 4, nous rappelons les notions d’ensemble, de table et de tableaux.

Remarque : la version minimale conseillée est la version Maple 5, la version 7 sur CD est mise à la disposition des
enseignants à la DGET (ISET Rades).
Par ailleurs, il est conseillé d’adopter l’ordre d’apparition des séances, mais sans obligation.
§1 LES FONCTIONS D’ENTRÉES SORTIES
• La fonction readstat()
Elle permet de lire ce que l’utilisateur tape au clavier.
La syntaxe est:
sans prompt readstat()
> a:=readstat();
10;
a := 10
avec prompt readstat(prompt)
> b:=readstat("b=");
b=12;
b := 12
• La fonction print(), lprint(), printf()
Elle permet d’écrire des informationd exemple
print(e1, e2, ... ), lprint(e1,e2,…), printf(format, liste d’expressions)
format: comme constante entre " " contient des caractères à afficher, des codes format repérés par "
avec : e1, e2,… n’importe que expression :
exemple :
> restart:a:=5:b:=4:print(2*x,5/3,a+b);

5
2 x, , 9
3
> lprint(2*x,5/3,a+b);
2*x, 5/3, 9
> printf(`expr1=%d\n expr2=%d\n expr3=%d`,a+b,a*b,a-b);
expr1=9
expr2=20
expr3=1
§2 LES STRUCTURES DE CONTRÔLE
♦ Les tests if… then
if condition1 then instruction 1
elif condition2 then instruction2 elif et else sont optionnels)
elif condition3 then instruction3 ...
else instructionN
fi;
elif signifie "autrement si" . La dernière instruction à exécuter doit être précédée de else
Exemple 1: résolution de l'équation du premier degré.
Modifiez les valeurs de a et de b , puis validez les lignes suivantes:
________________________________________________________________________ 4
 > a:=7:b:=3:
> if a<>0 then print(`Une solution : x `=-b/a)
elif b=0 then print(`Tout x est solution`)
else print(`Pas de solution`)
fi;
♦ La boucle while
Exécute une suite d'instructions, tant que la condition est vraie.
while condition do ... od;
Exemple 2: calcul de la somme des 100 premiers entiers naturels
> somme:=0:k:=-1:
while k<100 do k:=k+1:somme:=somme+k od:
`somme `=somme;
♦ La boucle for
Exécute une boucle pour une variable allant d'une valeur initiale à une valeur finale, avec un pas donné.
for variable from initiale to finale by pas do ... od;
from , by peuvent être omises ou écrites dans un ordre quelconque. Si l'on omet from , initiale vaut 1. Si l'on omet by ,
pas vaut 1.
Exemple 3: calcul de la somme des 100 premiers entiers naturels
> somme:=0:
for k from 0 to 100 do somme:=somme+k od:
`somme `=somme;
Exemple 4: calcul de la somme des entiers impairs inférieurs à 100
Ici, on omet from donc la première valeur de k est 1. La dernière valeur prise par k sera 99.
> somme:=0:
for k to 100 by 2 do somme:=somme+k od:
`somme `=somme;
for variable in expression do .. od;
Exemple 5: donner les nombres premiers de la liste [31,39,47,105]
> for k in [31,39,47,105] do
if isprime(k) then print(k,`est premier`) fi
od;
§3LES FONCTIONS ET PROCEDURES
♦ Les fonctions
Pour définir une fonction , on peut utiliser les syntaxes :
nom := var -> expr; pour une fonction d'une variable var
nom := (var1,var2,...,varN) -> expr; pour une fonction de N variables var1,var2,...,varN.
Exemple 6 :
> f:=x->exp(x)-x;
> g:=x,y,z,t->x^2-3*y+4*z-t;
On peut effectuer la composition des fonctions à l’aide de l'opérateur @ , l'opérateur de composition itérée @@ >
(f@g)(a);(g@f)(a); f@@N correspond à f o f o . . . o f (N fois)
♦ Les procédures
Un programme MAPLE peut être organisé en sous-programmes appelées procédures .
Une procédure, de type procedure , est définie par le mot-clé proc et peut être assignée à un nom de variable.
Pour définir une procédure intitulée nom , on utilisera la syntaxe suivante:
nom := proc (paramètres_formels)
global variables_globales; (la ligne global est optionnelle)
local variables_locales; (la ligne local est optionnelle)

description chaîne_de_description; (la ligne description est optionnelle)

option nom_option; (la ligne option est optionnelle)
. . . instructions . . . (corps de la procédure)
end; Exemple 7:
La procédure intitulée maxi calcule le plus grand de 2 entiers positifs.
Elle comporte 2 paramètres formels u et v. Leur type peut être omis, mais si on le veut le préciser, bien noter la syntaxe u ::
posint , v :: posint pour signifier que u et v sont de type posint .
Elle ne comporte ni variables globales, ni variables locales, mais une chaîne de description
de la procédure et une option de copyright.
> maxi:=proc(u::posint,v::posint); # calcule le plus grand de 2 entiers positifs

________________________________________________________________________ 5
 option `Copyright (c) 2001 A.Le Stang`;
if u<v then v else u fi; end;
> maxi(5,9);
Une variable locale est une variable qui n'est reconnue qu'à l'intérieur de la procédure, contrairement à une variable
globale accessible en dehors de la procédure.
Remarque importante:
Un paramètre formel passé à une procédure ne peut être modifié à l'intérieur de cette procédure
Exemple 8: Diviser un entier positif x par 2 tant qu'il est pair.
> div:=proc(x::posint)
while type(x,even) do x:=x/2 od;
end;
> div(48);
Error, (in div) illegal use of a formal parameter
La tentative d'affecter au paramètre formel x sa valeur divisée par 2 provoque une erreur.
On peut modifier la procédure de la manière suivante:
> div:=proc(x::posint)
local y;
y:=x;
while type(y,even) do y:=y/2 od;
y
end;
> div(48); #On obtient en effet successivement : 48,24,12,6,3.
3
> div(45);
45
return met fin à la procédure en donnant un résultat.
next permet de passer à la valeur suivante dans une itération.
break permet de sortir de la structure de contrôle en cours.
Récursivité:
Une procédure qui fait référence à elle même dans sa définition est une procédure récursive . Exemple 10:
factorielle de n
> factorielle := proc(n::nonnegint)
if n>0 then n*factorielle(n-1) else 1 fi;
end;
> factorielle(12);
Fonction error:
La fonction error permet de définir des messages d'erreur personnalisés.
Exemple 11: racine carrée de x
> racine := proc (x)
if x<0 then ERROR (`invalide x: %1`, x) else simplify(x^(1/2)) fi
end;
> racine(144);

§4 LISTES, ENSEMPLES, TABLES ET TABLEAUX

♦ listes
Une liste , de type list , est obtenue en plaçant une séquence entre les crochets [ et ] .
La liste vide se note [] .
Exemple :
> s:=a$2,b$3,alpha,beta;L:=[s];
♦ ensembles
Un ensemble , de type set , est obtenu en plaçant une séquence entre les accolades {et}. Les éléments sont rangés par
adresse , donc l'ordre initial n'est pas nécessairement conservé et les éléments en double sont supprimés. L'ensemble
vide se note {} .
Exemple : > s:=a$2,b$3,alpha,beta;e:={s};
On accède à chaque élément d'un ensemble par son rang, mais l'affectation est interdite :
> e[2];e[2..3];e[3]:=delta;
Error, cannot assign to a set
♦ tables
Une table est une structure indexée dont les indices (ou index ) peuvent être de n'importe quel type. La fonction table
permet de créer une table :

________________________________________________________________________ 6
Création d'une table vide: > v:=table();
Création d'une table T avec une liste de valeurs: >T:=table([valeur1,valeur2]);
Pour afficher le contenu d'une table, utiliser print ou eval >print(T),eval(U);
On peut modifier, créer un nouvel élément ou supprimer un élément par affectation :
> T[a]:=valeur3:U[2]:=valeur4:print(T),eval(U);
Une table peut être directement créée par assignation : > V[a]:=1:V[b]:=2:V[c]:=3:eval(V);
Fonctions agissant sur des tables:
> op(op(V)); > indices(V); > entries(V);
La fonction map permet d'appliquer une fonction sur les valeurs d'une table: >V:=map(sqrt,V);
La fonction copy permet d'effectuer une copie d'une table: > W:=copy(V);
♦ tableaux
Un tableau est une structure indexée, de type array, de plusieurs dimensions, dont les indices sont des entiers
appartenant à un intervalle a..b (de type range ).
La fonction array permet de créer un tableau . Des fonctions analogues à celles utilisées pour les tables existent :
Création d'un tableau à une dimension: > T:=array(1..3);
Création d'un tableau à une dimension avec initialisation partielle: >U:=array(1..5,[a,b,c]);
Création d'un tableau à 2 dimensions avec initialisation complète: >V:=array([[a,b,c],[d,e,f]]);
Création d'un tableau rectangulaire d'entiers par affectation à l'aide de boucles imbriquées:
> T:=array(1..2,1..3):
for i to 2 do
for j to 3 do
T[i,j]:=(i-1)*3+j;
od;
od:
print(T);
> op(op(T)); > indices(T); > entries(T); > map(x->x^2,T);
Conversion d'un tableau en liste (si la dimension est 1) ou en liste de listes (si la dimension est >1):
> convert(U,list);convert(T,listlist);
Conversion d'un tableau de dimension quelconque en ensemble: > convert(T,set);
> T:=convert([a,b,c,d],array); > U:=copy(T);

Complément d’exercices
Les exercices proposés sont traités par Maple , il est conseillé d’être présenté à l’aide
d’algorithmes simples (vus en 1ère année) . Le corrigé se trouve à la fin de ce document.
Exercice 1.2
Soient X,Y,Z trois entiers, tels que X<Y<Z et N un entier quelconque. Ecrire une suite d’instruction
Maple qui permet d’afficher dans l’ordre les trois petites valeurs parmi les quatre.
Exercice 2.2
Ecrire une procédure calculant le plus grand de 3 entiers naturels non nuls a,b,c.
Exercice 2.3
Ecrire une procédure second_degré(a,b,c) qui résout l’équation du second degré à coefficients
réels : en distinguant 3 cas selon le signe du discriminant.
Exercice 1.3
Etant donné un tableau carré T à n lignes et n colonnes,
1) Ecrire une procédure diagonale1(T,n) qui calcule la somme des éléments de T situés sur la
première diagonale.
2) Ecrire une procédure diagonale2(T,n) qui calcule la somme des éléments de T situés sur la
seconde diagonale.

Exercice 2.3
Ecrire une procédure transfert qui transforme une matrice M à deux dimensions dans un vecteur à
une dimension ( en utilisant rowdim(matrice) et coldiml(matrice))
Exemple :

________________________________________________________________________ 7
 a b c d
M =  e f g h  se transforme en V = [a b c d e f g h i j k l]
 i j k l 

Exercice 3.3
Ecrire une procédure permettant de :
Trier un tableau T de n éléments par :
1) Ordre décroissant.
2) Ordre croissant.

Problème 1
Considérons le tableau à deux dimensions, contenant pour chaque étudiant de la classe, ses
moyennes dans chacune des 10 matières qui lui sont enseignées. Chaque étudiant reçoit
obligatoirement un enseignement pour chacune des 10 matières. Les noms des étudiants et ceux de
chacune des 10 matières sont stockés dans des tableaux à une dimension.
Illustration :

MAT Analyse Informatiqu Algèbr Anglais …

NOM
e e
Emna MOYENNE :
Iskander
Syrine
Manel
Malek
…..
1 0 1 1 …
0 2 5 4
0 0 0 1
8 5 2 4
1 11 1 1
2 7 5
1 1 1 1
4 2 8 5
Nous vous demandons d’écrire
l’algorithme permettant l’édition du
récapitulatif des moyennes par matière,
de la moyenne générale de chaque étudiant et de la classe.
Problème 2
Ecrire l’algorithme détaillé permettant de saisir des nombres entiers dans un tableau de 10 lignes et
de 10 colonnes. Calculer les totaux par ligne et par colonne dans des tableaux TOTLIG et
TOTCOL.

________________________________________________________________________ 8
 Corrigé
Exercice 1.2
Exemple pour X=2, Y=5,Z=9, N=7
> restart:X:=2:Y:=5:Z:=9:N:=12:
if N<X then Z:=Y:Y:=X:X:=N
elif N<Y then Z:=Y:Y:=N
elif N<Z then Z:=N fi:print(X,Y,Z);
2, 5, 7
Exercice 2.2
> max3:=proc(a::posint,b::posint,c::posint)
local max2;
max2:=proc(x::posint,y::posint)
if x>y then x else y fi;
end;
max2(a,max2(b,c));
end;
> max3(5!,5^3,123);
125
> max3(5,53,123);
123
Exercice 3.2
> restart;
> second_degre:=proc(a,b,c)
local delta;
if a=0 then
ERROR (`a doit être non nul`)
else
delta:=b^2-4*a*c;
if delta<0 then print(`pas de solution`)
elif delta=0 then print(`racine double `,x=-b/(2*a))
else print (`2 racines distinctes `,x=(-b-sqrt(delta))/(2*a),x=(-b+sqrt(delta))/(2*a))
fi;
fi;
end;
> second_degre(1,7,2);
7 1 7 1
2 racines distinctes , x = − − 41 , x = − + 41
2 2 2 2
Exercice 1.3
> restart;
> diagonale2:=proc(T,n)
local i,s;
s:=0:
for i from 1 to n do
s:=s+T[i,n+1-i]
od:
print(s):
end;
> a:=array([[1,1,5],[0,2,0],[0,4,3]]);
 1 1 5
 
a :=  0 2 0
 0 4 3
 
________________________________________________________________________ 9
> diagonale2(a,3);
7
Exercice 2.3
> restart:
> with(linalg):
transfert:=proc(M)
local i,j,k,L,C,V;
k:=1:
V:=vector(rowdim(M)*coldim(M));
for i from 1 to rowdim(M) do
for j from 1 to coldim(M) do
V[k]:=M[i,j];k:=k+1:
od;
od;
print(V);end;

> M:=matrix(2,3,[a,b,c,c,d,e]);
a b c
M :=  
c d e
> transfert(M);
[ a , b , c, c, d , e ]
Exercice 3.3
> #tri décroissant
> restart; n:=5;
for i from 1 to n do
x[i]:=readstat(`x=`):
od:
for k from 1 to n-1 do
maxo:=x[k]: j:=k:
for i from k+1 to n do
if(x[i]>maxo) then
maxo:=x[i]: j:=i:
fi:
od:
s:=x[j]: x[j]:=x[k]: x[k]:=s:
od:
for i from 1 to n do
x[i]:=x[i]
od;
n := 5
x=-1;
x=2;
x=14;
x=124;
x=-154;
x1 := 124
x2 := 14
x3 := 2
x4 := -1
x5 := -154
________________________________________________________________________ 10
Problème 1
Méthode
Nous utilisons deux indices : indele, correspondant à l’indice ligne de l’étudiant, et indmat
correspondant à l’indice colonne des moyennes par matière.
Pour effectuer la moyenne générale de l’étudiant, nous additionnons les moyennes une à une et nous
divisons cette somme par 10, nous cumulons ces moyennes générales pour obtenir la moyenne de la
classe.

Algorithme relevé
Var
mat(1 :10), nom(1 :32) : tableau de chaîne de caractères
moyenne(1 :32,1 :10) : tableau de réels
indele, indmat : entiers
moygen, moycla : réels
début
(* saisie des différents tableau*)
POUR indmat de 1 à 10
Ecrire (`` entrer le nom de la matière numéro : ``, indmat)
Lire(mat(indmat))
FPOUR
POUR indele de 1 à 32
Ecrire(``entrer le nom de l’étudiant numéro : ``, indele)
Lire(nom(indele)
POUR indmat de 1 à 10
Ecrire(`` entrer sa moyenne obtenue en ``,mat(indmat))
Lire(moyenne(indele,indmat))
FPOUR
FPOUR
moycla ← 0
(*répétitive principale*)
POUR indele de 1 à 32
moygen ← 0
POUR indmat de 1 à 10
Moygen ← moygen,+moyenne(indele,indmat)
FPOUR
moycla ← moycla+moygen
FPOUR
Ecrire(``moyenne générale de la classe ``,moycla/32
Fin algorithme.

________________________________________________________________________ 11
 Séance 2 [3]

Fonctions réelles à une seule variable

I) Les fonctions usuelles : Rappel

Différents outils pour travailler avec les fonctions numériques (définition de la fonction, domaine
de définition, valeurs, point d'inflexion, dérivées, intégrales, limites, changements de variables,
développements limités et asymptotique, courbes etc.).
Un résumé des fonctions les plus utilisées est ci-dessous présenté.
Soit f une fonction à une variable x.
Remarque importante : f est une fonction mais f(x) est une expression polynomiale.
Rôle Syntaxe Exemple
Définir une fonction à > f:=x ->expression(x); ou > f:= x->(x^2 +1)/x;
une variable > f :=unapply(expression, x) ; 2
x + 1
f := x →
x
Calculer la fonction f(x) ; > f(2) ;
en 1 point x 5
2
Déterminer le > readlib(singular) : > readlib(singular): singular(f(x));
domaine de définition singular(f(x)); { x = 0 }, { x = ∞ }, { x = − ∞ }
Remarque : Il faut charger
singular avec readlib(singular)
avant de l’utiliser.
Etudier la parité de f > evalb(f(x)=f(-x)) ; > evalb(f(x)=f(-x));
par (f(x)=f(-x)) false
Etudier la continuité > readlib(iscont) : iscont(f(x), > readlib(iscont):iscont(f(x),x=-
sur ]a,b[. x=a..b) ; 1..1);
Le paramètre ‘closed’ > iscont(f(x), x=a..b, ‘closed’) ; false
permet d’étudier la
continuité sur [a,b]
Déterminer les points > readlib(discont) : discont(f(x), > discont(f(x),x) ;
de discontinuité x); {0}
Remarque : il n’est pas
nécessaire de charger discont
lorsque la fonction iscont est déjà
chargée.
Déterminer la > D(f) ; => donne la fonction > D(f);
2
fonction dérivée dérivée 1ere x + 1
x → 2 −
Remarque : @@ est l'opérateur x
2
de composition itérée
> (D@@2)(f); #ou D(D(f)) ;
> (D@@n)(f) ; => donne la 2
1 x + 1
fonction dérivée n ième x → −2 + 2
x 3
x

Dériver l’expression > diff(f(x),x) ; > Diff(f(x),x)= diff(f(x),x) ;

f(x) > Diff(f(x),x) ; => forme inerte 2 2
∂ x + 1 x + 1
= 2−
∂x x 2
>diff(f(x),x,...,x) ; ou x
diff(f(x),x$n) ; => dériver > diff(f(x), x$2);
l'expression f(x) n fois par
________________________________________________________________________ 12
 rapport à x 2
1 x + 1
Remarque : $ est l'opérateur de −2 + 2
x 3
répétition. x
Déterminer la > int(f(x), x) ; > Int(f(x),x) = int(f(x),x) ;
primitive de ⌠ 2
x + 1 1 2
l’expression f(x) 
 d x = x + ln( x )
 x 2

⌡
Intégrer l'expression > int(f(x), x=a..b) ; > Int (f(x),x = 1 .. 2) = int (f(x),x =
f(x) entre a et b Remarque : Int(f(x), x=a..b) est la 1 .. 2) ;
forme inerte de int. 2
⌠ 2
 x + 1 3

 d x = + ln( 2 )
 x 2

⌡
1
Déterminer un > asympt(f(x),x) ; > asympt(f(x),x) ;
développement 1
x+
asymptotique x
Déterminer un > taylor(f(x), x=a, ordre) ; > taylor(f(x), x=0, 2);
développement limité Error, does not have a taylor expansion,
en a try series()
> series(f(x), x=a, ordre) ; > series(f(x),x=0, 2) ;
Remarque : l’ordre est égal à 6 x-1+O(x)
par défaut (variable globale
Order)
Calculer la limite en > limit(f(x),x=a,dir) >
a Remarque : dir (optionel) est la Limit(f(x),x=0,left)=limit(f(x),x=0,
direction = left, right, real, left);
complex. 2
x + 1
Limit est la forme inerte. lim = −∞
x
x → 0-
Représenter > plot(f, H,V), plot3d(f, H,V), > plot(g, H,V), plot3d(g, H,V) ;
graphiquement. etc.
Pour représenter H et V étant les axes
simultanément Remarque : pour l’utilisation de
plusieurs fonctions il ces fonctions, consulter l’aide.
faut les encadrer par
des crochets :[ ]

II) Exercices à résoudre

Exercice N°1
a) Ecrire la commande Maple qui affecte à P l'expression e1/x(x(x+2))1/2 en utilisant les fonctions
exp, sqrt et *.
b) Convertir l’expression P en une fonction f (en utilisant unapply).
c) Cette fonction présente des branches infinies, déterminer les expressions affines associées à ces
asymptotes en utilisant la fonction limit.
Rappel : Si une courbe d’équation y= f(x) est asymptote à la droite d’équation y = ax+b, alors
f( x )
a= lim b= lim f( x ) − a x
x
x→ ∞ x→ ∞
et
d) Représenter la courbe avec ses asymptotes pour x compris entre -5 et 5.

________________________________________________________________________ 13
e) Ecrire une même commande Maple qui calcule et factorise l’expression de la dérivée de f à l'aide
de D et factor.
f) Ecrire une même commande Maple pour calculer et factoriser l’expression de la dérivée de f à
l'aide de diff et factor.
g) Ecrire une même commande Maple pour calculer et factoriser la dérivée seconde de f avec diff et
factor.
Exercice N°2
Etudier la fonction définie par :
2
x − 1
f( x ) =
x ln( x )
Cette étude consiste à :
 Définir la fonction ;
 Calculer la fonction f en certains points (positifs et négatifs);
 Déterminer le domaine de définition ;
 Tracer la courbe sur l’intervalle [0, +∞ [ ;
 Etudier le comportement de la fonction ;
- en 0 et +∞ ;
- au point 1. Déterminer dans ce cas, la tangente au point d’abscisse 1.
 Etudier les variations de la fonction f.

Alternative de correction

Exercice N°1

a°) Définition de f.

> restart: P:=exp(1/x)*sqrt((x*(x+2)));

b°) Convertir P en une fonction.

> f:=unapply(P,x);

c°) Etude des branches infinies.

> a:=limit((f(x))/x,x=infinity);

> b:=limit(f(x)- a*x, x=infinity);

________________________________________________________________________ 14
> eq:=a*x+b;

Vérifions le résultat avec asympt :

> asympt(f(x),x,1);

d°) Représentation de f et de eq

> plot([f(x),eq], x=-5..5, y=-10..10);

e°) Dérivée de f avec D.

> fD:=factor(D(f)(x));

f°) Dérivée de f avec diff.

> fd:=factor(diff(f(x),x));

g°) Dérivée seconde de f

________________________________________________________________________ 15
> fd2:=factor(diff(f(x),x$2));

Exercice N°2

Définir la fonction f

> restart: f:=x-> (x^2-1)/(x*ln(x));

Calculer la fonction en un point

> evalf(f(2));evalf(f(-2));

Domaine de définition

> readlib(singular):singular(f(x));

Comme Maple travaille avec des fonctions d'arguments complexes, la fonction logarithmique est
définie aussi pour x<0. Nous allons nous placer dans le cadre usuel des fonctions numériques et

prendre comme domaine de définition de f l'ensemble Df=]0,1[U]1,+ [

Tracer la fonction peut se faire de différentes manière.

> plot(f(x), x=0..10, y=0..10, style=point,discont = false);

> plot(f(x), x=0..10, y=0..10, style=point,discont = true);

> plot(f(x), x=0..infinity, y=0..infinity);

________________________________________________________________________ 16
> plot([f(x),x], x=0..infinity, y=0..infinity);

________________________________________________________________________ 17
On a l'impression trompeuse que les courbes se rejoignent alors qu'il n'en est rien :

> limit(f(x)-x, x=infinity);

Continuité ? f est continue en tout point du domaine de définition

> readlib(iscont):iscont(f(x),x=-1..infinity);

> readlib(discont):discont(f(x),x);

Etude de la fonction en 0, 1 et +

Etude en 0 : cherchons la limite en zéro (penser à utiliser la forme inerte de limit):

> Limit(f(x), x=0)=limit(f(x), x=0);

Comme on pouvait s'y attendre, Maple ne trouve pas de limite. Il faut donc préciser que la limite est
à droite de zéro

> Limit(f(x), x=0, right)=limit(f(x), x=0, right);

Etude en 1:

> Limit(f(x), x=1)=limit(f(x), x=1);

________________________________________________________________________ 18
Ici pas de Pb

Déterminons la tangente au point 1 en utilisant un développement limité:

> taylor(f(x), x=1 );

On peut penser à définir le prolongement par continuité de f en 1 par :

> fp:=x-> if x=1 then 2 else f(x) fi; diff(fp(x),x);

mais on remarque que cette dérivée n'est pas valable en 1.

Etude en + : cherchons une fonction asymptote (soit asympt, taylor ou series)

> asympt(f(x),x);series(f(x),x);taylor(f(x),x);

Error, does not have a taylor expansion, try series()

le résultat n'est autre que la fonction elle même. On peut quand même dire que la fonction f est

asymptote à x->

puisque le 2ième terme a pour limite 0

> limit(-1/(ln(x)*x), x=infinity);

tracons les 2 courbes sur un même dessin :

________________________________________________________________________ 19
> plot({f(x), x/ln(x)},x=0..50,y=0..50);

> plot({f(x), x/ln(x)},x=0..50,y=0..50, discont=true); plot({f(x), x/ln(x)},x=0..50,y=0..50,

color=[red,blue], style=[point,line], discont=true);

Variations :

On peut définir la fonction dérivée df par:

> df:=D(f);

La dérivée en x est donc :

> `f'(x)`= normal(df(x));

________________________________________________________________________ 20
ou encore

> `f'(x)`=normal(diff(f(x),x));

Cherchons les valeurs qui annulent cette dérivée:

Regarqons le domaine de définition de df avant :

> singular(df(x));

> solve(df(x)); fsolve(df(x));

> plot(df);

La dérivée est négative sur l'intervalle ]0, 1[ et positive sur l'intervalle ]1, + [

________________________________________________________________________ 21
 Séance 3 [3]
Fonctions réelles à deux variables

I) Les fonctions usuelles : Rappel

Les différents outils proposés pour travailler avec les fonctions numériques à une variable sont
valables également pour les fonctions à deux variables (définition de la fonction, domaine de
définition,valeurs, point d'inflexion, dérivées, intégrales, limites, changements de variables,
développements limités et asymptotiques, courbes etc.). Un résumé des fonctions les plus utilisées
est présenté au TP sur les fonctions numériques à une variable. Dans ce rappel on se focalisera sur
les fonctions présentant une syntaxe différente lorsque la fonction est à deux variables ou plus.
Soit g une fonction à deux variables x et y.
g fonction à deux Exemple
variables
Définition g:=->(x,y)->expression(x,y) ; > restart: g:=(x,y)->x^2*sin(y)/x;
g :=unapply(expression, g := ( x , y ) → x sin ( y )
(x,y)) ;
Calcul en 1 g(x,y) ; > g(3,sqrt(3));
point 3 sin( 3 )
Domaine de readlib(singular) : > readlib(singular) : singular(g(x,y)) ;
définition singular(g(x,y)) ; { x = ∞ , y = y } , { y = y, x = − ∞ }
Fonction dérivée > D[1](g) ; => fonction > D[1](g) ;
dérivée par rapport à la 1ere ( x, y ) → x cos ( y )
variable. > D[2](g) ;
> D[2](g) ; => fonction ( x, y ) → sin( y )
dérivée par rapport à la 2ième > D[1,2](g) ;
variable. ( x, y ) → cos ( y )
> D[1,2](g) ; => même ordre. > (D[1]@@2)(g) ;
0
> (D[1]@@n)(g) ; => (D[2]@@2)(g) ;
fonction dérivée nième par ( x, y ) → − x sin( y )
rapport à la 1ere variable.
> (D[2]@@n)(g) ; =>
fonction dérivée nième par
rapport à la 2ième variable.
Dériver >diff(g(x,y),x,y) ;=>dériver > Diff(g(x,y),x,y)=diff(g(x,y),x,y);
l’expression l'expression g(x,y) par 2
∂
rapport à x puis par rapport à x sin( y ) = cos ( y )
∂y∂x
y.
>Diff(g(x,y),x,y) ; => forme > Diff(g(x,y),x,y$2)=diff(g(x,y),x,y$2) ;
3
inerte de diff(g(x,y),x,y) ∂
x sin( y ) = − sin( y )
> diff(g(x,y),x,y$n) ; => 2
∂y ∂x
dériver g(x) 1 fois par rapport
à x puis n fois par rapport à y.
Primitive de > int(g(x,y), x) ; ou > Int(g(x,y),x)=int(g(x,y),x);
g(x,y) int(g(x,y), y) ; ⌠ 1 2
 x sin( y ) d x = x sin( y )
⌡ 2
Intégrer > int(g(x,y), x=a..b) ; ou > Int(x*sin(y),y = 0 .. x) = int(x*sin(y),y = 0 ..
l'expression int(g(x,y), y=a..b) ; x) ;
________________________________________________________________________ 22
entre a et b > Int(g(x,y), x=a..b) ; ou x
⌠
Int(g(x,y), y=a..b) ; => forme  x sin( y ) d y = − x cos ( x ) + x
⌡
inerte 0
Développement > asympt(g(x,y),x) ; > asympt(g(x,y),x);
asymptotique > asympt(g(x,y),y) ; x sin( y )
Développement > taylor(g(x,y), x=a, ordre) ; > taylor(g(x,y),x=0, 4);
limité en a > taylor(g(x,y), y=a, ordre) ; sin( y ) x
Remarque : l’ordre est égal à > taylor(g(x,y),y=0, 4);
6 par défaut (variable globale 1 3 4
xy− x y + O( y )
Order) 6
Calcul de limite > limit(g(x,y),x=a,dir) ; >Limit(g(x,y),x=0,left)=limit(g(x,y),x=0,left);
en a > limit(g(x,y),y=a,dir) ; lim x sin( y ) = 0
Remarque : dir (optionel) est x → 0-
la direction = left, right, real,
complex.
Limit est la forme inerte.
Représentation > plot3d(g, H,V) > plot3d(g(x,y),x=-1..1,y=-1..1);
graphique H et V étant les axes >plot3d(g(x,y),x=-1..1,y=-1..1,
Remarque : pour l’utilisation coords=spherical,style=patch);
de cette fonction, consulter
l’aide.

II) Exercice à résoudre

Etudier la fonction g (en particulier la continuité et la différentiabilité ) définie par :
g(0, 0 ) = 0
2 2  1 
g ( x , y ) = ( x + y ) sin 
 2 2 
x + y 
pour tout (x,y) ≠ (0,0)
Dans cet exercice, il faut avoir la sagesse de vérifier les résultats affichés par Maple
mathématiquement.

Alternative de Correction

Exercice :

Définir la fonction g :

> restart:g:=(x,y)->if x=0 and y=0 then 0 else (x^2+y^2)*sin(1/(x^2+y^2)) fi;

Domaine de définition :

> readlib(singular):singular(g(x,y));

Vérifions par représentation graphique:

> plot3d(g(x,y), x=-10..10, y=-10..10);

________________________________________________________________________ 23
> plot3d(g(x,y), x=0..10, y=0..10,coords=spherical,style=patch );

Continuité en (0,0) :soit en faisant un changement de variables soit en passant aux

coordonnées polaires.

passons aux coordonnées polaires

> z:=g(rho*cos(theta), rho*sin(theta));

en plus simple :

> z:=simplify(z);

Calcul de la limite

> limit(z,rho=0);

La fonction est donc continue en (0,0)

Dérivabilité en (0,0)

> dgx:=D[1](g) ;# fonction dérivée partielle par rapport à x

________________________________________________________________________ 24
> dgy:=D[2](g) ;# fonction dérivée partielle par rapport à y

Ces définitions nous conviennent parfaitement ainsi :

> dgx(x,y);

> dgx(0,0);

> dgy(x,y);

> dgy(0,0);

ou encore

> Diff('g(x,y)', x)=eval(diff(g(x,y), x), x=0); #idem pour y

On peut procéder autrement en vérifiant les taux d'accroissements et

qui doivent avoir des limites en 0 surtout lorsque les fonctions dérivées ne sont
pas définies en ces points.

> tx0:=(g(x,0)-g(0,0))/x; limit(tx0, x=0);

________________________________________________________________________ 25
Regardons les dérivées partielles d'ordre 2

> dg2x:=(D[1]@@2)(g) ;# fonction dérivée partielle par rapport à x

> dg2x(0,0);

> dg2y:=(D[2]@@2)(g) ;# fonction dérivée partielle d'ordre 2 par rapport à y

> dg2y(0,0);

> plot3d(dgx,-2..2,-2..2, axes=BOXED);

>

Séance 4 [4]

________________________________________________________________________ 26
 Polynômes et fractions rationnelles
Pour les exemples suivants, on suppose que P est le polynôme défini comme suit :
>P :=(x^2+x+2)^5 ;
5
P := ( x2 + x + 2 )
Fonction Rôle Exemple
expand Développer un polynôme >expand(P) ;
.................................................................
sort Ordonner un polynôme dans l’ordre >sort(expand(P)) ;
décroissant de la puissance de ses termes ………………………………………
> sort(x^2-y^2*x^3+x^2*y^4+y+x , x);
………………………………………….
> sort(x^2-y^2*x^3+x^2*y^4+y+x , y);
…………………………………………
factor Factoriser un polynôme ou une fraction >factor(x^2-1) ;
…………………………………………
simplify Simplifier un polynôme ou une fraction >simplify((x^3+1)/(x+1)^2) ;
………………………………………
degree Donner le degré d’un polynôme >degree(P) ;
ldegree Donner le plus petit degré d’un polynôme >ldegree(P) ;
lcoeff Donner le coefficient du plus grand terme >lcoeff(P) ;
d’un polynôme
tcoeff Donner le coefficient du plus petit terme d’un >tcoeff(P) ;
polynôme
coeff Donner le coefficient d’un terme quelconque >coeff(P,x^2) = coeff(P, x, 2) ;
d’un polynôme .................................................................
gcd Donner le plus grand commun diviseur de > gcd(x^2-y^2,x^3-y^3);
deux polynômes …………………………………………
> gcd(6,-8, a , b);a ;b ;
…………………………………………
lcm Donner le plus petit commun multiple de > lcm(x^2-y^2,x^3-y^3);
deux polynômes
collect Grouper les coefficients d’un même terme Q :=a*ln(x)-ln(x)*x-x ; collect(Q,x) ;
…………………………………………
…………………………………………
divide Vérifier si deux polynômes sont divisibles >divide(x^3-y^3,x-y) ;
>divide(x^3-y^3,x-y , quotient) ,
quotient ;
…………………………………………
quo Donner le quotient de la division de deux >quo(x^3+x+1,x^2+x+1, x) ;
polynômes …………………………………………
>quo(x^3+x+1,x^2+x+1, x , reste) ,
reste ;
…………………………………………
rem Donner le reste de la division de deux >rem(x^3+x+1,x^2+x+1, x) ;
polynômes …………………………………………
>rem(x^3+x+1,x^2+x+1, x , quotient) ,
quotient ;
normal Mettre une fraction sous sa forme normalisée >normal((x^2-y^2)/(x-y)^3) ;
…………………………………………
________________________________________________________________________ 27
eval Evaluer un polynôme pour une valeur donnée >eval(P,x=1) ;
de sa variable .................................................................
>eval(x^2-y^2,{x=0,y=1}) ;
.................................................................
subs Substituer une expression par une autre dans >subs(x^2=y , y=z , x^2+2*y) =
un polynôme subs(y=z , subs(x^2=y , x^2+2*y));
…………………………………………
> subs(y=z , x^2=y , x^2+2*y) ;
…………………………………………
solve Résoudre des équations ou des inéquations > solve(x-2*y=0)=solve(x-2*y);
>solve({x+2*y=3,-x^2+2*y=1},{x,y}) =
solve({x+2*y=3,-x^2+2*y=1});
…………………………………………
nops Nombre des opérandes d’une expression >nops(P) ;
op Liste des opérandes d’une expression >op(P) ;
>op(n,P) ;#l’opérande du rang n dans P
>op(1..2,P) ; #liste des opérandes allant
du rang 1 au rang 2
> Convert(F,parfrac,x) ; décomposer la fraction F en éléments simples
exple : > convert ((x^5+1) / (x^4-x^2), parfrac, x) ;

EXERCICE 1 :
2 2
1. Définir le polynôme P = (3x y + xy - x - 2y +xy +2)(x + 1)
2. Développer P
3. Ordonner les termes de P selon xy
2 2
4. Donner les coefficients des termes xy et x y
2 2
5. Regrouper les termes en x y et en xy

EXERCICE 2 :
6 x2 + 18 x − 24
On considère la fraction rationnelle F définie par F :=
x2 + 2
1. Définir F
2. Factoriser le numérateur de F
3. Trouver les racines du dénominateur de F et le factoriser
4. Décomposer F en éléments simples

Exercice 3 :
Trouver un polynôme P tel que
P2 = x8 – 2x6 – 3 x4- 4x2 + 4
Exercice 4 :
x6
Soit la fraction rationnelle F définie par : F := 2
( x2 + 1 ) ( x + 1 )2
La décomposition de F en éléments simples dans R s’écrit :
bx+c dx+e f g
G := a + 2 + + +
x + 1 ( x2 + 1 ) 2 x + 1 ( x + 1 )2
On réduit les fractions composantes de G au même dénominateur et on identifie les numérateurs de
F et de G. En déduire les valeurs de a, b, c, d, e, f, g.

________________________________________________________________________ 28
Correction :
Exercice 1 :

> restart;F:=(6*x^2+18*x-24)/(x^2+2);
6 x2 + 18 x − 24
F :=
x2 + 2
> factor(numer(F));
6 (x + 4) (x − 1)
> solve(denom(F));
I 2 , −I 2
> factor(denom(F),{I,sqrt(2)});
−( −x + I 2 ) ( x + I 2 )
> convert(F,parfrac,x);
−36 + 18 x
6+
x2 + 2
Exercice 2 :
> restart;P:=sum(a[i]*x^i,i=0..4);
P := a0 + a1 x + a2 x2 + a3 x3 + a4 x4
> E:=expand(P^2)-(x**8+2*x**6-3*x**4-4*x**2+4);
2 2 2 2 2
E := a0 + a1 x2 + a2 x4 + a3 x6 + a4 x8 + 2 a1 x3 a2 + 2 a1 x4 a3 + 2 a1 x5 a4 + 2 a2 x5 a3
+ 2 a2 x6 a4 + 2 a3 x7 a4 + 2 a0 a1 x + 2 a0 a2 x2 + 2 a0 a3 x3 + 2 a0 a4 x4 − x8 − 2 x6
+ 3 x4 + 4 x 2 − 4
> solve({seq(coeff(E,x,k),k=0..8)});

{ a1 = 0, a0 = -2, a3 = 0, a2 = 1, a4 = 1 }, { a1 = 0, a3 = 0, a2 = -1, a0 = 2, a4 = -1 }
> assign(");P;
2 − x2 − x4

Exercice 3 :
> restart;F:=x^6/((x^2+1)^2*(x+1)^2);
x6
F := 2
( x2 + 1 ) ( x + 1 )2
> G:= a + (b*x+c)/(x^2+1) + (d*x+e)/(x^2+1)^2 + f/(x+1) + g/(x+1)^2;denom(G);

bx+c dx+e f g
G := a + + + +
x 2 + 1 ( x2 + 1 ) 2 x + 1 ( x + 1 ) 2
2
( x2 + 1 ) ( x + 1 ) 2
> N:=convert(numer(G),polynom)-x**6;

N := g + a + c + b x + d x + 2 b x2 + 2 c x3 + 2 c x + d x3 + c x4 + 2 b x4 + b x5 + a x6 + 2 a x5
+ 3 a x 4 + 4 a x3 + 3 a x2 + 2 a x + 2 b x 3 + 2 c x 2 − x 6 + e + f + f x 4 + 2 f x 2 + f x + g x4
+ 2 g x2 + 2 f x3 + f x5 + 2 d x2 + e x2 + 2 e x
> V:=expand((a*((x**2+1)**2)*((x+1)**2))+ (b*x+c)*((x**2+1)*((x+1)**2)) + (d*x+e)*(x+1)^2
+ f*(x+1)*(x**2+1)**2 + g*(x^2+1)^2)-x**6;
________________________________________________________________________ 29
V := g + a + c + b x + d x + 2 b x2 + 2 c x3 + 2 c x + d x3 + c x4 + 2 b x4 + b x5 + a x6 + 2 a x5
+ 3 a x 4 + 4 a x3 + 3 a x 2 + 2 a x + 2 b x3 + 2 c x 2 − x 6 + e + f + f x4 + 2 f x2 + f x + g x 4
+ 2 g x2 + 2 f x3 + f x5 + 2 d x2 + e x2 + 2 e x
> N-V;
0
> solve({seq(coeff(N,x,K)=0,K=0..degree(N))},{a,b,c,d,e,f,g});

-1 1 1
{ a = 1, c = , b = -1, d = , e = 0, g = , f = -1 }
4 2 4
> assign(");F=G;
1 1 1
−x − x
x6 4 2 1 4
= 1 + + − +
2
( x2 + 1 ) ( x + 1 )2 x 2 + 1 ( x 2 + 1 )2 x + 1 ( x + 1 ) 2

________________________________________________________________________ 30
 Séance 5 [2]

Nombres Complexes / Fonctions Complexes

I. Rappel de cours :

Un nombre complexe s’écrit de différentes formes:

- une forme cartésienne : a+I.b
- une forme trigonométrique : r ( cos( θ ) + I sin( θ ) )
(I θ)
- une forme exponentielle: r e
- une forme polaire : ( r, θ )
Remarque : le complexe I doit s’écrire en majuscule
Exemples:
>2–3*I;
2–3I
>( 4-2*I )*( 1-I ) ;
6-2I
> ( x- ( 1 - I ) * y )+(y + 2 * x * I) ;
x + ( 1-I ) y +y + 2 I x

Plusieurs fonctions de manipulation des nombres complexes sont fournies par MAPLE, parmi
lesquelles, on peut citer :

Rôle Syntaxe Exemple

Partie réelle d’un nombre
complexe
Partie imaginaire d’un
nombre complexe
Evaluation d’un nombre
complexe
Conjugué d’un nombre
complexe
Argument d’un nombre
complexe
Conversion en coordonnées
polaires
Transformation géométrique
dans le plan complexe
Re(nombre complexe) >Re((2-I) * (3+5*I)) ;
11
Im(nombre complexe) >Im((2-I) * (3+5*I)) ;
7
evalc( nombre complexe) >evalc(2^(1+I)) ;
2*cos(ln(2))+2*I*sin(ln(2))
conjugate(nombre complexe) >conjugate((3+5*I)*(1-2*I)) ;
13 + I
argument(nombre complexe) >argument(3+I) ;
arctan(1/3)
polar(nombre complexe) >polar(3+4*I) ;
polar(3+4*I)
conformal(f(z),z=zi..zf) ; > f:=z->z^3;
f:=z  z3
with (plots):
conformal(f(z),z=-1-I..1+I);

II. Exercices d’application :

________________________________________________________________________ 31
Exercice1 :
Donner la forme cartésienne des nombres complexes suivants :
a. (1-i )n b. (-1-i )7 c. -2*(cos π /4 -i sin π /4 ) d. -7+2 i
3*(cos π /6 + i sin π /6) 5+4i

Exercice 2 :
Convertir la forme cartésienne des nombres suivants en forme polaire :
a. −6 + 6 I 3 c. -7 + 24 I e. π
4 3
b. −1 + I 3 d. + I
5 5
Exercice 3 :
Trouver le modules des nombres complexes suivants :
5 + 11 I 3 72 65
a. b. + I c. 648 − 648 I 3
7−4I 3 97 97

Exercice 4 :
Résoudre les équations à variables complexes :
3 2 2
a. x − x ( 1 + a + I a ) + a x ( 1 + I + I a ) − I a = 0
b. ( 1 − I ) z = ( 1 + I ) z + 4
2+I 1−2I
c.
• x6 − I = 0
• Déterminer, de 2 manières différentes, les coordonnées polaires de chaque racine trouvée.

Exercice 5 :
Montrer que si z = a+bi (a,b ∈ IR) satisfait l'équation z 2 + z + 1 = 0 , alors le conjugué de z satisfait
aussi cette équation.

Exercice 6:
Soit f une fonction définie sur C par f(z)= z + 2 I
z−2I
a. Déterminer le domaine de définition de f
b. Trouver l’image de (1+i)3 par la fonction f. Donner sa forme cartésienne et sa forme polaire
c. Déterminer les points fixes relatifs à f
d. Résoudre l’équation f(z)=0

e. Représenter sur le plan complexe la courbe de f telle z varie entre (-1-2 i) et (1+ i ).

________________________________________________________________________ 32
Correction
Exercice1 : donner la forme cartésienne des nombres complexes suivants:
> restart;c:=evalc((1-I)^n);
1 1
cos n π  − I e sin n π 
( 1/2 n ln( 2 ) ) ( 1/2 n ln( 2 ) )
c := e
 4  4 
> evalc((-2*(cos(Pi/4)-I*sin(Pi/4)))/(3*(cos(Pi/6)+I*sin(Pi/6))));
1 1 1 1
− 2 3+ 2 + I  2 3+ 2 
6 6  6 6 
> evalc((-1-I)^7);
-8 + 8 I
> evalc((-7+2*I)/(5+4*I));
-27 38
+ I
41 41
Exercice2 : convertir la forme cartésienne en forme polaire
> restart;a:=convert(-6+6*sqrt(3)*I,polar);
2
a := polar 12, π 
 3 
> b:=convert(-1+sqrt(3)*I,polar);
2
b := polar 2, π 
 3 
> c:=convert(Pi,polar);
c := polar( π, 0 )
> d:=convert(-7+24*I,polar);
24
d := polar 25, −arctan  + π 
 7 
> e:=convert(4/5+(3/5)*I,polar);
3
e := polar 1, arctan  
 4
Exercice 3: module d'un nombre complexe:
> restart;evalf(sqrt(Re(evalc((5+11*sqrt(3)*I)/(7-4*sqrt(3)*I)))^2+Im(evalc((5+11*sqrt(3)*I)/(7-
4*sqrt(3)*I)))^2));
evalf(sqrt(Re(evalc((13+5*I)/(13-5*I)))^2+Im(evalc((13+5*I)/(13-5*I)))^2));
evalf(sqrt(Re(evalc(648-648*sqrt(3)*I))^2+Im(evalc(648-648*sqrt(3)*I))^2));
2.
1.
1296.
Exercice 4: résoudre des équations à variables complexes:
> r:=solve(x^3-x^2*(1+a+I*a)+a*x*(1+I+I*a)-I*a^2,x);
r := a, I a, 1
> s:=solve((1-I)*z/(2+I)=((1+I)*z+4)/(1-2*I),z);
s := -1 + I
> t:=solve(x^6-I=0,x);
1 1 1 1 1 1
t :=  − + 5 + I 2 5 + 5  −I ,  − − 5 + I 2 5 − 5  −I ,
 4 4 4   4 4 4 
1
− − 1 1 1 1 1
 5 − I 2 5 − 5  −I ,  − + 5 − I 2 5 + 5  −I ,
 4 4 4   4 4 4 
1 1 1 1
2 − I 2, − 2+ I 2
2 2 2 2
> for i from 1 to 6 do
print(`les coordonnées polaires de la racine n°`,i,` sont: `);

________________________________________________________________________ 33
print(`module=`),evalf(sqrt(Re(evalc(t[i]))^2+Im(evalc(t[i]))^2));
print(`argument=`),argument(evalc(t[i]));
od;
"les coordonnées polaires de la racine n°", 1, " sont: "
"module="
1.000000000
"argument="

 1 5 + 5 + 1 − 1 5  2 
   
 4  8 8  
arctan
  1 5 − 1  2 + 1 5 + 5 
   
 8 8  4 
"les coordonnées polaires de la racine n°", 2, " sont: "
"module="
.9999999999
"argument="

 1 5 − 5 + 1 + 1 5  2 
   
4 8 8 
arctan  + π
  − 1 − 1 5  2 + 1 5 − 5 
  8 8 
 4 
"les coordonnées polaires de la racine n°", 3, " sont: "
"module="
.9999999999
"argument="
 − 1 5 − 5 + 1 + 1 5  2 
   
 4  8 8  +π
arctan
  − 1 − 1 5  2 − 1 5 − 5 
   
 8 8  4 
"les coordonnées polaires de la racine n°", 4, " sont: "
"module="
1.000000000
"argument="
 − 1 5 + 5 +  1 − 1 5  2 
 4 8 8  
arctan   −π
  1 5 − 1  2 − 1 5 + 5 
   
 8 8  4 
"les coordonnées polaires de la racine n°", 5, " sont: "
"module="
1.
"argument="
________________________________________________________________________ 34
 1
− π
4
"les coordonnées polaires de la racine n°", 6, " sont: "
"module="
1.
"argument="
3
π
4
> for i from 1 to 6 do
polar(evalc(t[i]));
od;

 2 2
   1 1 1   1  1 1  
polar   5 −  2 + 5 + 5  +  5 + 5 +  − 5  2  ,
   8 8 4   4  8 8  



 1 5 + 5 + 1 − 1 5  2 
    
4 8 8 
arctan 
  1 5 − 1  2 + 1 5 + 5  
    
 8 8  4 

 2 2

polar   − 1 − 1 5  2 + 1 5 − 5  +  1 5 − 5 +  1 + 1 5  2  ,
   8 8  4   4  8 8  


 1 5 − 5 + 1 + 1 5  2  
    
arctan
4  8 8   + π 
 
  − 1 − 1 5  2 + 1 5 − 5  

  8 8 
  
4

 2 2

polar − 1 − 1 5  2 − 1 5 − 5  + − 1 5 − 5 + 1 + 1 5  2  ,
       

  8 8  4   4 8 8  


 − 1 5 − 5 + 1 + 1 5  2  
    
4  8 8 
arctan  + π
  − 1 − 1 5  2 − 1 5 − 5  
   
 
 8 8  4 

________________________________________________________________________ 35
 
 2 2

polar 1 5 − 1 2 − 1 5 + 5  + − 1 5 + 5 + 1 − 1 5  2  ,
       
 8 8  4   4 8 8  



 − 1 5 + 5 + 1 − 1 5  2  
  8 8   
4 
arctan  − π
  1 5 − 1  2 − 1 5 + 5  
    
 8 8 4  
1
polar 1, − π 
 4 
3
polar 1, π 
 4 
Exercice 5: montrer que si z = a+bi (a,b appartiennent à IR) satisfait l'équation z^2+z+1 = 0 alors le
conjugué de z satisfait aussi cette équation
> restart;
z:=a+b*I;tab:=solve(z**2+z+1=0);
z := a + I b
1 1 1 1
tab := { b = b, a = − − I b + I 3 }, { b = b, a = − − I b − I 3 }
2 2 2 2
> assign(tab[1]);
x:=evalc(conjugate(z));
1 1
x := − − I 3
2 2
> a:='a';b:='b';assign(tab[2]);
y:=evalc(conjugate(z));
a := a
b := b
1 1
y := − + I 3
2 2
> evalc(x**2+x+1);
0
> evalc(y**2+y+1);
0
Exercice 6: étude de fonctions complexes
> restart;f:=z->(z+2*I)/(z-2*I);
z+2I
f := z →
z−2I
> singular(f(z));
{z = 2 I}
> c:=f((1+I)^3);polar(c);
c := 1 − 2 I
polar( 5 , −arctan( 2 ) )
> solve(f(z)=z);
1 1 1 1
+I− -3 + 12 I , + I + -3 + 12 I
2 2 2 2
> solve(f(z)=0);
-2 I
________________________________________________________________________ 36
> with(plots):conformal(f(z),z=-1-2*I..1+I);

Séance 6 [5]
Algèbre linéaire :
Partie A : Fonctions prédéfinies

Pour charger un package, il faut utiliser la commande (with). Pour utiliser les fonctions relatives à
l'algèbre linéaire il faut charger la bibliothèque linalg "linear algebra" par la commande
with(linalg);
N.B : A chaque restart il faudra recharger la bibliothèque.

Déclaration Utilisation
>with(linalg) :
Chargement de la Ainsi, avec cette commande, les
bibliothèque d’algèbre >with(nom_du_package); différentes fonctions prédéfinies pour
linéaire la manipulation des matrices et
vecteurs sont chargées.
Entrée d’une 1°>M 1:=matrix(nbl,nbc,[liste des > M1:=matrix(3,3,[1,2,7,8,0,1,-5,6,2]);
matrice: éléments de ma matrice]) ; [ 1 2 7]
Il existe différentes 2°>M2 :=matrix([[éléments ligne [ 8 0 1]
manières pour [-5 6 2]
1],[ éléments linne 2],[ éléments
déclarer une matrice, >M2:=matrix([[1,0,-1], [2,0,1 ], [1,0,-
ligne 3]]) ;
nous présentons les 2]]);
3°>f :=(i,j)->i+j-1 ; [1 0 -1]
principales: M3 :=matrix(nbl,nbc,f) ; [2 0 1]
(où nbl, nbc et f désignent [1 0 -2]
respectivement le nombre de > f:=(i,j)->i+j-1;
ligne, le nombre de colonnes, et f := (i, j)  i+j-1
une fonction à deux variables (i et > M3:=matrix(3,3,f);
j) désignant l’indice ligne et [1 2 3]
[2 3 4]
l’indice colonne
[3 4 5]
4°>Matrice à coefficients
>M4:=matrix(3,2,[]);
indéterminés [m[1, 1] m[1, 2] ]
>M4:=matrix (nbl,nbc,[]); [m[2, 1] m[2, 2] ]
#[] désigne la liste vide [m[3, 1] m[3, 2] ]
5°>matrice diagonale >M5:=diag(3,2,1);#matrice diagonale
>M5 :=diag(éléments en [3 0 0]
diagonale) [0 2 0]
[0 0 1]
ou encore
>M51:=diag(2$3);
[2 0 0]
________________________________________________________________________ 37
 Remarque
> M1; # en tapant la lettre
seulement la matrice ne s'affiche
[0 2 0]
pas, il faut utiliser la commande [0 0 2]
evalm
> evalm(M1);

Entrée d’un vecteur: > V:=vector([liste des

Un vecteur est une coordonnées du vecteur]); > V:=vector([1,2,-1]);
V := [1, 2, -1]
matrice ligne
Opérations
élémentaires sur les
matrices
1. Somme de
deux matrices. >matadd(M1,M2); >matadd(M1,M2);
# deux possibilités >evalm(M1&+M2); [ 2 2 6]
[10 0 2]
[-4 6 0]

2. Produit de deux
matrices. >multiply(M1,M2); >evalm(M1&*M2);
[12 0 -13 ]
# deux possibilités >evalm(M1&*M2); [ 9 0 -10]
[9 0 7]

>multiply(M2,M1);
[ 6 -4 5]
[-3 10 16]
[11 -10 3]

> scalarmul(M1,3);
3. Multiplication [ 3 6 21]
d'une matrice > scalarmul(Matrice, scalaire); [ 24 0 3]
par un scalaire. [-15 18 6]

Calcul de >det(M1);
déterminant >det(matrice) ; 288

>transpose(M1) ;
[1 8 -5]
Transposée d’une
>transpose(matrice) ; [2 0 6]
matrice [7 1 2]

>evalm(M1&^2) ; #M1 au carré

[-18 44 23]
Puissance de
>evalm(matrice&^puissance) ; [ 3 22 58]
matrice [ 33 2 -25]

>inverse(matrice) ; # si la matrice >inverse(M1) ;

[-1/48 19/144 1/144 ]
Inverse d’une est inversible det(m)<>0 et la
[-7/96 37/288 55/288]
matrice matrice m est carré [ 1/6 -1 /18 -1 /18 ]
.

________________________________________________________________________ 38
 Soit la matrice N
>N:=matrix(3,3,[18,42,12,3,-9,6,-9,-
Rang d’une matrice >rank(matrice); 21,-6]);
>rank(N) ;
2
Trace d’une >trace(N) ;
>trace(matrice) ;
matrice 3
Noyau d’une >kernel(N) ;
>kernel(matrice) ;
matrice {[-5, 1, 4]}
Image d’une >colspace(N) ;
>colspace(matrice) ;
matrice {([0, 1, 0]), ([1, 0, -1/2])}
Valeurs propres >eigenvals(N);
>eigenvals(matrice) ;
d’une matrice 0, -9, 12
>eigenvects(matrice) ;
cette commande retourne une liste >eigenvects(N) ;
Vecteurs propres qui représente la valeur propre, sa [-9, 1, {[-2, 1, 1]}], [0, 1, {[-5, 1, 4]}], [12, 1,
d’une matrice multiplicité et enfin une base du {[-2, 0, 1]}]
sous espace propre associé.

Polynôme >charpoly(N,x) ;
>charpoly(matrice,variable) ;
caractéristique x3 - 3 x 2 - 108 x
Soit la matrice suivante :
>N:=matrix([[18,42,12],[3,-9,6], [-9,-
Réduction de >matrice_résultat :=jordan(matri
21,-6]]);
Jordan ce, ‘matrice_de _passage’) ;
> N1:=jordan(N,'P');
Maple peut calculer
la forme réduite de [12 0 0]
Jordan. On peut de N1 := [ 0 -9 0]
plus récupérer la Remarque [ 0 0 0]
matrice de passage. N’oubliez pas les cotes pour la >evalm(P);
matrice de passage [2 2/3 -5/3]
[0 -1/3 1/3 ]
[-1 -1/3 4/3 ]

Partie B : Exercices d'applications directes

Exercice 1 Opérations élémentaires
Soit les deux matrices suivantes A1 et A2 :
[0 1 1 1 ] [1 0 1 0]
[1 0 -1 -1] [0 0 0 0]
A1 := [1 -1 0 -1] A2 := [1 0 0 1]
[1 -1 -1 0] [0 1 0 0]
1- Définir les deux matrices A1 et A2 , de deux manières différentes.
2- Calculer 3A1, A1+A2, A1*A2, A2*A1, 2A1+3A2
3- Donner la matrice inverse de A1,
4- Donner la transposée de A2.

Exercice 2: Valeurs propres, vecteurs propres, polynôme caractéristique

Soit la matrice suivante A:
[ 1 -1 2]
A := [-2 1 0]
[ 1 1 3]
1- Définir A.
________________________________________________________________________ 39
 2- Donner la transposée de A
3- Calculer A* TA*A
4- Donner le déterminant de A puis son inverse
5- Donner le rang de A, son noyau, sa trace, puis son image
6- Calculer A à la puissance 3
7- Donner les valeurs propres, les vecteurs propres puis le polynôme caractéristique de A.

________________________________________________________________________ 40
Correction
Exercice 1
> A1:=matrix(4,4,[0,1,1,1,1,0,-1,-1,1,-1,0,-1,1,-1,-1,0]);
> A2:=matrix([[1,0,1,0],[0,0,0,0],[1,0,0,1],[0,1,0,0]]);
> scalarmul(A1,3);
> matadd(A1,A2) ;
> multiply(A1,A2);
> multiply(A2,A1);
> matadd(A1,A2,2,3); #matadd(m,m1,u,v) où u et v désignent deux scalaires retourne la matrice
résultat u*m+v*m1
> inverse(A1) ;
> transpose(A2) ;
[0 1 1 1] [1 0 1 0]
[1 0 -1 -1] [0 0 0 0]
A1:= [1 -1 0 -1] A2 := [1 0 0 1]
[1 -1 -1 0] [0 1 0 0]
3A1 [0 3 3 3] A1+A2 [1 1 2 1]
[3 0 -3 -3] [1 0 -1 -1]
[3 -3 0 -3] [2 -1 0 0]
A1*A2 [3 -3 -3 0] [1 0 -1 0]
[1 1 0 1]
[0 -1 1 -1]
[1 -1 1 0]
[0 0 1 -1]
A2*A1
[1 0 1 0]
[0 0 0 0]
[1 0 0 1]
[1 0 -1 -1]
2A1+3A2
[3 2 5 2]
[2 0 -2 -2]
[5 -2 0 1]
[2 1 -2 0]
(A1)-1
[2/3 1/3 1/3 1/3 ]
[1/3 2/3 -1/3 -1/3]
[1/3 -1/3 2/3 -1/3]
[1/3 -1/3 -1/3 2/3 ]
t
(A2)
[1 0 1 0]
[0 0 0 1]
[1 0 0 0]
[0 0 1 0]
Exercice 2
1)> A:=matrix(3,3,[1,-1,2,-2,1,0,1,1,3]);
[ 1 -1 2]
A := [-2 1 0]
[ 1 1 3]
2)> TA:=transpose(A);
[1 -2 1]
TA := [-1 1 1]
[2 0 3]

________________________________________________________________________ 41
3)>evalm(A&*TA&*A); ou encore >multiply(A,TA,A);
[ 18 -3 30]
[-14 7 -9]
[ 19 4 45]
4)> det(A);
-9
> inverse(A);
[-1/3 -5/9 2/9]
[-2/3 -1/9 4/9]
[1/3 2/9 1/9]
5) > rank(A); kernel(A); trace(A); colspace(A);
3
{}
5
{[0, 0, 1], [0, 1, 0], [1, 0, 0]}

6) >eigenvals(A); eigenvects(A); charpoly(A,x);

-1, 3, 3
[3, 2, {[2, -2, 1]}], [-1, 1, {[-2, -2, 1]}]
x 3- 5 x2 + 3 x + 9

________________________________________________________________________ 42
 Séance 7 [5]
Partie C : Exercices appliqués aux mathématiques
Remarque : l’enseignant peut traiter un ou plusieurs exercices de la partie I et un ou plusieurs
exercices de la partie II.
Partie I : Utilisation des fonctions prédéfinies
Exercice 1 : Diagonalisation de matrice
Diagonaliser ou trigonaliser la matrice suivante, donner la matrice de passage et vérifier que l’on
retrouve bien la matrice initiale.
[0 1 1 1]
[1 0 -1 -1]
M := [1 -1 0 -1]
[1 -1 -1 0]
Correction
> M:=matrix([[0,1, 1, 1],[1,0,-1,-1],[1,-1,0,-1],[1,-1,-1,0]]);
> K:=jordan(M,'Q');
[-3 0 0 0]
[0 1 0 0]
K := [0 0 1 0]
[0 0 0 1]
> evalm(Q);
[ 1/4 11/4 2 1]
[-1/4 1/4 0 0]
[-1/4 5/4 1 0]
[-1/4 5/4 1 1]
> evalm(Q &* K &* Q^(-1));
[0 1 1 1]
[1 0 -1 -1]
[1 -1 0 -1]
[1 -1 -1 0]
Exercice 2 : Puissance nième
Calculer la puissance nième de la matrice A suivante, pour un entier n indéterminé (après l’avoir
diagonalisée). Puis, donner un résultat numérique pour n=1, n=2, n=5
[ 58 52 36]
A := [ -29 187 9]
[-145 65 219]
 Correction
> A:=matrix([[58, 52, 36], [-29, 187, 9], [-145, 65, 219]]);
[ 58 52 36]
A := [ -29 187 9]
[-145 65 219]
> eig:=eigenvects(A);
eig := [116, 1, {[4, 1, 5]}], [174, 2, {[1, 0, 29/9], [0, 1, -13/9]}]
> J:=jordan(A,'P'); # détermination de la matrice diagonale
[174 0 0]
J := [ 0 116 0]
[ 0 0 174]
>evalm(P); # matrice de pasage
[-20 /29 2 9/29]
[-1/2 1/2 0 ]
[-3/2 5/2 1 ]
> puiss:=x->x^n;
puiss := x -> x n
________________________________________________________________________ 43
> Jn:=map(puiss,J);
[174 n 0 0]
Jn :=[ 0 116 n 0]
[0 0 174 n ]
> An:=evalm(P &* Jn &* P^(-1)); # la matrice An
An :=
[-174 n + 2 *116 n 26/29 * 174 n - 26/29 *116 n 18/29 *174n-18/29 *116n ]
[-1/2 174 n+1/2*116n 71/58* 174 n-13/58 116 n 9/58*174n-9/58 *116 n ]
[- 5/2 174 n +5/2 *116 n 65/58*174 n -65/58* 116 n 103/58*174 n –45/58*116n]
>n:=1;
> map(eval,An);
[ 58 52 36]
[ -29 187 9]
[-145 65 219]
> n:=2;
> map(eval,An);
[ -3364 15080 10440]
[ -8410 34046 2610]
[-42050 18850 43326]
> n:=5;
> map(eval,An);
[-117487861472 124164594112 85960103616]
[ -69245639024 190535843152 21490025904]
[-346228195120 155205742640 266944824144]

Exercice 3 : Réduction de Gauss

Soit la matrice A suivante :
[3 6 7]
A := [2 7 9]
[2 5 4]
Calculer la réduction de Gauss de la matrice A
> A := matrix(3,3,[3,6,7,2,7,9,2,5,4]);
[3 6 7]
A := [2 7 9]
[2 5 4]
> gausselim(A,'r','d');
[3 6 7 ]
[0 3 13/3 ]
[0 0 -19/9]
> r;
3
> d;
-19
Partie II : Programmation
Exercice 1
Ecrivez un programme calculant la multiplication de deux matrices C=AxB. Utiliser la formule

p
mathématique C ij = ∑ Aij Bkj .
k =1

________________________________________________________________________ 44
Correction
Présentation de la méthode
Le but de cet exercice de programmation est d’écrire une procédure capable de calculer la
multiplication de deux matrices (sans utiliser la fonction &*…).
Vous aurez besoin de deux instructions.
• rowdim(matrice) : renvoie le nombre de lignes de matrice :
• coldim(matrice) : renvoie le nombre de colonnes de matrice.
1. paramètres et algorithmes.
Les paramètres de la procédure sont A et B, les deux matrices que l’on veut multiplier.
Rappelons ici la définition de la multiplication matricielle. Si C=AB( A matrice mp, B matrice
pn, on a :
p
C ij = ∑ Aij Bkj (1)
k =1
Notre programme va donc être assez simple. On sait que la matrice C sera une matrice mn ( m
lignes, n colonne). Il va falloir calculer la valeur de tous les coefficients de cette matrice en
utilisant la formule (1).
2. procédure
> with(linalg):
multmat:=proc(A,B)
local C,i,j,k:
C:=matrix(rowdim(A),coldim(B));
for i from 1 to rowdim(C) do
for j from 1 to coldim(C) do
C[i,j]:=0;
for k from 1 to coldim(A) do
C[i,j]:=C[i,j]+A[i,k]*B[k,j]
od;
od;
od;
RETURN(C);end;

Utilisation et commentaire de la procédure

> A:=matrix(3,2,[1,2,1,4,2,3]);
>B:=matrix(2,2,[1,2,4,2]);C:=multmat(A,B);print(C);
 1 2
   9 6
A :=  1 4  1 2 
17 10

 2 3 B :=   C := C 
   4 2 14
 10
Exercice 2
Ecrivez des programmes parmi le complément d’exercices de la séance 1 ou autres, en utilisant les
instructions de structures conditionnelles, de structures répétitives, matrices et vecteurs, etc.

Exercice 3
Programmation Maple de la solution d’un système linéaire (méthode de Gauss) [6] et [7]
1. Problème [6]
Le but de ce TP est d’appliquer une méthode itérative, celle de Gauss, pour la résolution des
systèmes d'équations linéaires. On supposera que dans ce cas on dispose d'autant d'équations que
d'inconnues. On examinera par la suite le cas où cette condition n'est pas satisfaite.

________________________________________________________________________ 45
Considérons le système d'équations linéaires suivant que l'on cherche à résoudre :
a11x1+a12x2+...+a1nxn = b1

a21x1+a22x2+...+a2nxn = b2 (1)

an1x1+an2x2+...+annxn = bn

Ce système peut aussi s'écrire :

A.x = b (2)

avec A = [aij ](i,j = 1...n), xT = [x1,...,xn] et bT = [b1,...,bn].

2. Méthode de Gauss
La méthode de Gauss est basée sur le constat suivant : le système linéaire reste invariant pour les
trois opérations suivantes effectuées dans n'importe quel ordre et un nombre de fois indéterminé :

1. Permutation de lignes de la matrice A (et donc de b)

2. Multiplication d'une ligne par une constante non nulle
3. Addition d'une ligne à une autre ligne

Exposé de la méthode
En combinant les opérations précédentes, on peut transformer la matrice A en une matrice
triangulaire supérieure par le processus itératif suivant :

1. On garde la première ligne inchangée

2. On suppose a11 ≠ 0. On soustrait à la ième ligne de A et de b (i = 2,...,n) la première ligne
multipliée par la quantité (ai1/a11). Les matrices A et b prennent alors la forme :

   
 a11 a12 ... a1n   b1 
 0 a22(1) a23(1) a24(1)   b2(1) 
A(1) = b(1) =
 .... ... ... ...   .  (3)
 0 an2(1) an3(1) ann(1)   bn(1) 
   

avec
a1i
ai,j(1) = aij−ai1 i≥2 j≥1 (4)
a11
b1
bi(1) = bi−ai1 i≥2 (5)
a11

On répète l'étape précédente en supposant cette fois-ci a22(1) ≠ 0. On garde alors les deux premières
lignes inchangées et on retranche (ai1(1)/a22(1))×(2ème ligne) à la ième ligne (i = 3,...,n). En tout le
processus est effectué (n−1) fois. La matrice A devient alors triangulaire supérieure.

________________________________________________________________________ 46
 3 Soit R la matrice triangulaire inférieure obtenue et c la transformée de la matrice b. Nous
avons :
u11x1+u12x2+...+u1nxn = c1
0+u22x2+...+u2nxn = c2
.
0+0+...+unnxn = cn

4 Finalement la solution est obtenue par simple substitution :

( −∑k = i+1nuikxk+ci)
xi = (i = n,n−1,...,2,1)
rii (6)

3. Principe

L'algorithme consiste à se ramener à un système triangulaire équivalent et à résoudre ce système.

Soit A(1) = A et b(1) = b. Supposons a11(1) non nul, ce qu'il est toujours possible d'obtenir par un
éventuel échange de lignes. Dans le tableau (A(1) | b(1)), on effectue une combinaison linéaire des

lignes l1 et li , i = 2,... n, en remplaçant li par , i = 2,... n. La matrice obtenue est de la

forme

et

Le système d'origine est équivalent au nouveau système A(2) x = b(2).

On recommence ensuite une combinaison linéaire analogue des lignes l2 et li , i = 3,... n, de

(A(2) | b(2)) de façon à annuler les éléments sous-diagonaux de la deuxième colonne de A(2), et ainsi
de suite jusqu'à ce que la matrice soit devenue triangulaire supérieure.

On résout, ensuite, le système triangulaire obtenu.

4. Algorithme
1e étape: triangularisation de A, c'est-à-dire transformation du système en un système
équivalent à matrice triangulaire supérieure.

A(1) = A, b(1) = b.

________________________________________________________________________ 47
2e étape: résolution du système triangulaire A(n) x = b(n).

5. Exemple
Résolution du système Ax = b avec :

et

• Résolution manuelle (avec les fractions)

1e étape: triangularisation de A

---------------------------------------

---------------------------------------

________________________________________________________________________ 48
 ---------------------------------------

2e étape: résolution du système triangulaire A(4)x = b(4)

____________________________________________________________________
6. Travail demandé
On se donne les déclarations suivantes :

Constante Nmax = 100

A : tableau [1..Nmax, 1..Nmax] de réel
b : tableau[1..Nmax] de réel

1. Ecrire une procédure Saisie (N) qui permet de saisir une matrice carré A et un vecteur b
d’ordres N (N <=Nmax) ?
2. Ecrire une procédure PIVOGauss (A1, b1, N) qui applique les transformations
nécessaires à la matrice A1 et au vecteur B1 de façon que A1 devienne une matrice
triangulaire ?
3. Ecrire une procédure Remontée (A2, b2, x, N) qui résout un système linéaire
triangulaire de N équations ? A2x = b2 et affiche le résultat ?
4. Ecrire un algorithme MethodeGAUSS appelant les procédures citées ci-dessus et qui
permet de résoudre le système Ax = b ?
5. Donner le code Maple correspondant aux différentes procédures ?
6. Application : Résoudre le système Ax = b avec :

et

7. Résoudre le même système en appliquant la fonction solve de Maple ? Comparer les

deux résultats ?

Correction

Solution d’un système linéaire :

Les algorithmes :

________________________________________________________________________ 49
 1. Procédure SAISIE (N : entier)
var
i,j : entier
Début
pour i de 1 à N faire
écrire (" donner l’élément d’indice ",i, "du vecteur b ")
lire (b[i])
fin pour
pour i de 1 à N faire
pour j de 1 à N faire
écrire (" donner l’élément d’indices ",i, j, "de la matrice A ")
lire (A[i,j])
fin pour
fin pour
fin Procédure SAISIE
2. Procédure PIVOGauss (var A1 : tableau[1..Nmax, 1..Nmax] de réels,
var b1 : tableau[1..Nmax] de réels, N : entier,
var ok : logique)
var
i,j,m : entier
p : réel
Début
i1
ok  vrai {aucun pivot nul pour le moment}
tant que (( i<= N) et ok ) faire
{s’assurer avant de diviser que le pivot est utilisable }
si (A1[i,i] = 0) alors
ok  faux
sinon
pour j de i à N faire
p  -A1 [j,i] / A1[i,i]
b1[j]  b1[j] + p*b1[i]
pour m de i+1 à N faire
A1[j,m]  A1[j,m] + p * A1[i,m]
fin Pour
A1[j,i]  0
fin Pour
fin si
i  i+1
fin tant que
fin Procédure PIVOGauss
3. Procédure Remontée (A2 : tableau[1..Nmax, 1..Nmax] de réels,
b2 : tableau[1..Nmax] de réels,
var x tableau |1..Nmax] de réels, N : entier)
var
i, j : entier
S : réel
Début
x[N]  b2[N] / A2[N, N]
Pour i de N-1 à 1 pas = -1 faire

________________________________________________________________________ 50
 S0
Pour j de i+1 à N faire
S  S + A2[i,j] * x[j]
fin Pour
x[i]  (b2[i] – S) / A2[i,i]
fin Pour

{ afficher le résultat }
Pour i de 1 à N faire
écrire (x[i])
fin Pour
Fin Procédure Remontée
4. Algorithme MethodeGauss
Constante Nmax = 100
var
A : tableau [1..Nmax, 1..Nmax] de réels
b : tableau[1..Nmax] de réels
x : tableau [1..Nmax] de réels
N : réel
OK : logique
Début
écrire (« donner la dimension de la matrice A »)
Saisie (N)
PIVOGauss (A, b, N, OK)
Si (OK) alors
Remontée (A, b, x, N)
sinon
écrire (« pivot nul dans ! pas de solutions »)
fin si
Fin MethodeGauss

Traduction Maple
> restart;
> #Réponse question 1
> SAISIE:=proc(N :: integer)
local i,j;
global A, b;
for i from 1 to N
do
print(`donner la valeur ayant pour indice`,i, `du vecteur b`);
b[i] := readstat();
od:
for i from 1 to N
do
for j from 1 to N do
print(`donner la valeur ayant pour indice`,i,j, `de la
matrice A`);
A[i,j] := readstat();
od:
od:

________________________________________________________________________ 51
end:

> #Réponse question 2

> PIVOGauss := proc(ok1,A1,b1,N)
local i,j,m,p,ok;

i := 1:
ok1:=1:
ok:=eval(ok1,2):
while ((i<=N) and (ok = 1))
do
if (A1[i,i] = 0) then
ok := 0;
else
for j from i+1 to N
do
p := -A1[j,i] / A1[i,i];
b1[j]:=b1[j] + p * b1[i];
for m from i+1 to N
do
A1[j,m] := A1[j,m] + p*A1[i,m];
od:
A1[j,i] := 0;
od:
fi;
i := i+1;
od:
end:

> #Réponse question 3

> Remontee := proc (A2, b2, x, N)
local i,j,s;
x[N] := b2[N] / A2[N,N]:
for i from N-1 to 1 by -1
do
s := 0;
for j from i+1 to N
do
s := s + A2[i,j] * x[j];
od:
x[i] := (b2[i] - s ) / A2[i,i];
od:
print(`matrice A triangularisée : `,A2);
print(`vecteur X solution = `);
for i from 1 to N
do
print(`x[`,i,`]`,x[i]);
od:
end;

________________________________________________________________________ 52
> #Réponse question 4,5,6 ; Algorithme MethodeGauss
> Nmax := 4;
#pour simplifier, je considère Nmax=N

A := array(1..Nmax, 1..Nmax);
b := array(1..Nmax);
print(`donner la dimension de la matrice A`);
N := readstat();
SAISIE (N);
print(`affichage de A et B`,A, b);
ok := 'ok':
PIVOGauss(ok,A, b, N);
if (ok = 1) then
x:='x':
Remontee( A, b, x, N);
print(`x= `,x);
else
print(`erreur , pivot nul`);
fi:

> #Réponse question 7

> xx:=array(1..N) :
> eqns:={8*xx[1]-4*xx[2]+3*xx[3]+7*xx[4]=12,
4*xx[1]+2*xx[2]-6*xx[3]+4*xx[4]=1,
-16*xx[1]+6*xx[2]-2*xx[3]-15*xx[4]=-19,
6*xx[1]+10*xx[2]-15*xx[3]+10*xx[4]=1};
>

> solve(eqns);

Remarque : Reprendre la résolution de ce problème avec la fonction prédéfinie « gausselim » et

comparer les résultats obtenus par cette dernière méthode et ceux obtenus par la méthode
précédente que nous avons définie ci-dessus.

________________________________________________________________________ 53
 Séance 8 [4]
Suites Numériques
(Terme général, Suite Récurrente, Somme, Produit, Convergence)

I. Rappel de cours :

Fonction Rôle Exemple

unapply Définir une suite numérique U par > V := unapply ( n / 2, n) ;
son terme général U(n) (U(n) doit
être en fonction de n) et sa
variable inconnue n

rsolve Déterminer le terme général d’une > rsolve({U(n+2)= U(n+1) + U(n),

suite récurrente (arithmétique ou U(0) = 1, U(1) = 1},U ) ;
géométrique)

Sum Exprimer la somme des termes >Sum(V(k),K=0..5) ;

d’une suite numérique sans donner
sa valeur (forme inerte) > Sum(V(k),K=0..n) ;

sum Calculer la somme des termes >sum(V(k),K=0..5) ;

d’une suite numérique (forme
analytique) > sum(V(k),K=0..n) ;

Product Exprimer le produit des termes >Product(V(k),K=0..5) ;

d’une suite numérique sans donner
sa valeur (forme inerte) > Product(V(k),K=0..n) ;

product Calculer le produit des termes >product(V(k),K=0..5) ;

d’une suite numérique (forme
analytique) > product(V(k),K=0..n) ;

Limit Représenter la limite d’une >Limit(U(n), n= infinity) ;

fonction sans la calculer
(remarque : Un = f(n))

limit Calculer la limite d’une fonction > limit(U(n), n= infinity) ;

II. Exercices d’application :

Exercice I :
Soit la suite U(n)n∈ IN définie par le terme général suivant :
U( n ) = c n + 1
avec c un nombre réel non nul
1. Trouver c pour que la somme des 6 premiers termes de U soit égale à 16
2. Pour la valeur trouvée de c, calculer U2 , U3, U4
3. Exprimer puis évaluer le produit de U pour k allant de 0 à 5
Exercice II :
On considère la suite U(n)n∈IN telle que :

________________________________________________________________________ 54
 n
S= ∑ U( k ) = 1 - 1/3 + 1/5 - 1/7 + 1/9 + …
k=0

1. Trouver le terme général de U et le définir

2. Evaluer U7 , U10, U12, à trois chiffres après la virgule
3. Exprimer et calculer S pour les 5 premiers termes de U ( utiliser 2 méthodes : fonctions
prédéfinie et programmation), évaluer S sur 7 digits
4. Calculer la limite de S quand n = 0
5. Exprimer et évaluer le produit P des 5 premiers termes de U
6. Montrer que la suite U est convergente
Exercice III :
Soient U(n)n∈IN et V(n)n∈IN* deux suites réelles ayant les formes récurrentes suivantes :
U0 = 1 V1 = 1 / 2

 
1. Définir les suites U et V
2. Calculer la somme des (n+1) premiers termes de U
3. Evaluer le produit des trois premiers termes de V
4. Etudier la convergence de U et de V
Exercice IV :
On considère la suite U(n)n∈IN* définie comme suit :
U1 = 7
Un+1 = 1/6 Un + 5

1. Définir la suite U
2. Montrer que U converge vers 6
3. Pour tout n appartenant à IN, on pose :
Vn = Un – a avec a : réel
Déterminer a pour que la suite V soit une suite géométrique de raison 1/6.
Exercice V :
Soient les deux suites récurrentes suivantes :
U0 = -1 V0 = 1
Un = 2 Vn + 5  Vn = 2 Un-1 +3
2. Calculer les valeurs des i èmes termes des suites U et V lorsque i=3, 4, 5 et ce en utilisant :
a. les fonctions prédéfinies
b. la programmation
3
2. Calculer la somme S suivante : S= ∑ ( U( k ) − V( k ) ) , en utilisant
k=0
a. la fonction prédéfinie « sum »
b. la programmation
3
U( k )
3. Calculer le produit P suivant : ∏ , en utilisant
k=0
V( k )

________________________________________________________________________ 55
 c. la fonction prédéfinie « product »
d. la programmation
4. Etudier la convergence de U et de V.

Correction
EXERCICE I :
> restart;
> u:=unapply(c*n+1,n);
u := n → c n + 1
> solve(sum(u(k),k=0..5)=16,{c});
assign(");
2
{c = }
3
> u(2);u(3);u(4);
Product(u(k),k=0..5)=evalf(product(u(k),k=0..5));
7
3
3
11
3
5
2
∏  3 k + 1  = 185.3703704
k=0
EXERCICE II:
> restart;
u:=unapply((-1)^n/(1+2*n),n);
( -1 )n
u := n →
1+2n
> evalf(u(7),2);evalf(u(10),2);evalf(u(12),2);
-.067
.048
.040
> Digits:=7;
> Sum(u(k),k=0..4)=evalf(sum(u(k),k=0..4));
Limit(sum(u(k),k=0..n),n=0)=limit(sum(u(k),k=0..n),n=0);
Digits := 7
4
( -1 )k
∑ 1 + 2 k = .8349206
k=0
(n + 1)  3 5 1 3 1
( -1 )  + n   Ψ + n  − Ψ + n  
1 1 2   4 2  4 2  = 1
lim π −
n→0 4 2 3 + 2 n
> Product(u(k),k=0..4)=evalf(product(u(k),k=0..4));
4
( -1 )k
∏ 1 + 2 k = .001058201
k=0
> limit(u(n),n=infinity);
0
EXERCICE III:
> restart;
> rsolve({u(n)=((n/2)*u(n-1)+n)/n,u(0)=1},u);
________________________________________________________________________ 56
 n
1
−  + 2
2
> u:=unapply(",n);u(n-1);
n
1
u := n → −  + 2
2
(n − 1)
1
−  +2
2
> v:=unapply(simplify((n/2)* "),n);
1 ( −n + 1 )
v := n → − n ( 2 − 2)
2
> s:=sum(u(k),k=0..n);
(n + 1)
1
s := 2   +2n
2
> evalf(product(v(k),k=1..3));
1.968750000
> limit(u(n),n=infinity);
2

> limit(v(n),n=infinity);
∞
EXERCICE IV :
> restart;r:=rsolve({U(n+1)=(1/6)*U(n)+5,U(1)=7},U);
n
 1
r := 6   + 6
6
> U:=unapply(r,n);
n
 1
U := n → 6   + 6
6
> limit(U(k),k=infinity);
6
> V:=unapply(U(n)-a,n);
n
 1
V := n → 6   + 6 − a
6
> simplify(solve({V(n)/V(n-1)=1/6},{a}));
{a = 6}
> assign(");V(1);
1
EXERCICE V :
1.a/
> restart;a:=rsolve({u(n)=4*u(n-1)+11,u(0)=-1},u);
8 11
a := 4 n −
3 3
> u:=unapply(a,n);
v:=unapply(2*u(n-1)+3,n);
8 n 11
u := n → 4 −
3 3

________________________________________________________________________ 57
 16 ( n − 1 ) 13
v := n → 4 −
3 3
> seq(u(i),i=3..5);seq(v(i),i=3..5);
167, 679, 2727
81, 337, 1361
1.b/
> U:=proc(n) option remember;
if n=0 then -1 else 2*V(n)+5 fi;
end;

V:=proc(n) option remember;

if n=0 then 1 else 2*U(n-1)+3 fi;
end;

U(3),U(4),U(5);
V(3),V(4),V(5);
U := proc(n) option remember; if n = 0 then -1 else 2×V( n ) + 5 end if end proc
V := proc(n) option remember; if n = 0 then 1 else 2×U( n − 1 ) + 3 end if end proc
167, 679, 2727
81, 337, 1361
2.a/
> Sum(u(k)-v(k),k=0..3)=-1-1+evalf(sum(u(k)-v(k),k=1..3));
3
8 2 16 ( k − 1 )
∑  3 4k + 3 − 3 4  = 112.
k=0

2.b/
> S:=U(0)-V(0);
for i from 1 to 3 do
S:=S+U(i)-V(i);
od;
evalf(S);
S := -2
S := 4
S := 26
S := 112
112.
3.a/ > Product(u(k)/v(k),k=0..3)=(-1/1)*(evalf(product(u(k)/v(k),k=
1..3)));
8 k 11
3 4 −
3 3
∏ 16 ( k − 1 ) 13 = -33.10893246
k=0 4 −
3 3
3.b/
> P:=U(0)/V(0);

________________________________________________________________________ 58
for i from 1 to 3 do
P:=P*(U(i)/V(i));
od;
evalf(P);
P := -1
P := -7
-273
P :=
17
-15197
P :=
459
-33.10893246
4/ > if limit (u(n),n=infinity)=infinity then print(`la suite U est
divergente`) else print(`la suite U est convergente`) fi;

"la suite U est divergente"

> if limit (v(n),n=infinity)=infinity then print("la suite V est
divergente") else print("la suite V est convergente") fi;

"la suite V est divergente"

________________________________________________________________________ 59
 Séance 9 [8]

Equations différentielles ET Systèmes différentiels

Tableau récapitulatif

Fonction Rôle Exemple

dsolve({équation, conditions Résolution des eq :=diff (y(x),x$2)-3*diff(y(x),x) +
initiales}, {fonction}) ; équations 2*y(x)=x-1 ;
Les conditions initiales doivent différentielles dsolve({eq, D(y)(0)=5,y(0)=1}, y(x)) ;
être entrées sous la forme :
fct(var)=valeur
D(fct)(var)=valeur
D@n(fct)(var)=valeur

dsolve({équations, conditions Résolution des eq1 :=diff(x(t),t)=x(t)+2*y(t)-z(t) ;

initiales}, {fonctions}) ; systèmes d’équations eq2 := diff(y(t),t)=2*x(t)+4*y(t)-2*z(t) ;
Les conditions initiales doivent différentielles eq3 := diff(z(t),t)=-x(t)-2*y(t)+z(t) ;
être entrées sous la forme : dsolve({eq1,eq2,eq3},{x(t),y(t),z(t)} );
fct(var)=valeur
D(fct)(var)=valeur
D@n(fct)(var)=valeur

dsolve({équation, conditions Résolution numérique equa :=diff(y(x),x)+sin(y(x))=x ;

initiales}, des équations dsolve({equa ,y(0)=0},y(x),numeric) ;
{fonction},numeric) ; différentielles

odeplot(fonction, [var1, Représentation de la equa :=diff(y(x),x)+sin(y(x))=x ;

var2], min1..max1, option) ; fonction (après s:=dsolve({equa ,y(0)=0},y(x),numeric) ;
résolution numérique) with(plots);
odeplot(s,[x,y(x)],-5..5);

Introduction
La résolution des équations différentielles avec Maple se fait à l’aide de la fonction dsolve :
Cette fonction nécessite au moins deux arguments :
Le premier des deux est un ensemble contenant les équations et, s’il y a lieu, les conditions initiales.
Le second est un ensemble contenant les noms des fonctions inconnues. (sous la forme y(x) pour
une fonction y dont x est la variable).
Ces ensembles sont donc délimités par des accolades mais, comme souvent avec Maple, si l’un de
ces ensembles se réduit à un élément, il n’est pas nécessaire de mettre d’accolades.
Certaines équations différentielles qui ne peuvent être résolues formellement, peuvent être résolues
numériquement en introduisant numeric dans la ligne de commande dsolve. Une représentation de
la fonction peut alors être obtenue à l’aide de la fonction odeplot qui fait partie du package plots :
> odeplot(fonction, [var1, var2], min1..max1, option) ;

1/ Equation différentielle de premier ordre

La forme générale d’une équation différentielle est : a*y’(x)+b*y(x)+c=0
En Maple, la fonction inconnue doit s’écrire y(x), sa dérivée peut s’écrire diff(y(x),x) ou D(y)(x),
mais si on utilise une condition initiale portant sur la dérivée, elle doit impérativement être écrite
avec l’opérateur D.
a/ Résolution sans condition initiale
________________________________________________________________________ 60
Soit l’équation :

La résolution est :

Maple utilise comme constante d’intégration un identificateur commençant par un souligné.

Attention :
Bien mettre y(x) pour préciser la fonction recherchée et non pas y ce qui conduirait à un message
d’erreur.
Si on veut obtenir le résultat de y(x) sous forme d’une expression, on peut utiliser la commande
subs :

La fonction dsolve ne retourne pas toujours, comme dans l’exemple précédent, une forme explicite
des solutions d’une équation différentielle. Avec l’option explicit, la fonction dsolve retourne, si
possible, une équation explicite de la courbe intégrale.

b/ Résolution avec condition initiale

Pour tenir compte des conditions initiales, le premier argument de la fonction dsolve contiendra,
dans un ensemble, en plus de l’équation, l’ensemble de ces conditions.

2/ Equation différentielle d’ordre 2

La dérivée seconde de y(x) s’écrit diff(y(x),x,x) ou (D@@2)(y)(x), mais les conditions initiales
portant sur les dérivées doivent s’écrire à l’aide de D.

________________________________________________________________________ 61
Si on veut résoudre le cas général de l’équation classique y’’+a.y=0 avec les conditions initiales
y(0)=0 et y’(0)=1 on peut écrire :

Exemple :
Prenons l’exemple de l’équation du mouvement de la pendule pesante (on se rappelle que cette
& t    2  t   0 )
équation s’écrit pour de petits mouvements &

Notons que si l’on omet les conditions initiales, Maple introduit ses propres constantes :

3/ Système d’équations différentielles

Pour résoudre un système différentiel on utilise dsolve avec deux arguments : le premier est
l’ensemble entre accolade des équations du système et éventuellement des conditions initiales. Le
second est l’ensemble des fonctions inconnues.

Maple retourne un ensemble de deux équations et introduit les constantes qui lui sont nécessaires en
utilisant des identificateurs commençant par le caractère souligné.
Le même système mais avec conditions initiales :

Lorsque l’on demande la résolution d’un système, il faut donner autant de fonctions inconnues que
d’équations sinon on obtient un message d’erreur.

4/ Résolution numérique des équations différentielles

Certaines équations ne peuvent être résolues formellement et doivent être résolues numériquement,
c’est le cas de l’équation ci-dessous :

________________________________________________________________________ 62
Maple reste sans réponse. Il faut donc résoudre numériquement en rajoutant l’argument numérique
à la fonction dsolve. Attention, ici des conditions initiales numériques sont nécessaires :

Maple nous montre que la solution est une procédure. Pour l’exécuter :

Maple retourne, sous forme de liste, la valeur de la variable et la valeur prise par la fonction.
Il est impossible de représenter directement cette fonction. Il faut nécessairement avoir recours à la
fonction odeplot qui fait partie du package plots.

________________________________________________________________________ 63
 EXERCICES

Exercice 1
On considère l'équation suivante : xy'+y=1/(1-x) (1)
1. Donner toutes les solutions de (1) sur ] -¥;0[ et ] 0;1[.
2. Quelles sont les solutions sur ] -¥; 1[?

Exercice 2
y  x  x2   0
Résoudre dans IR l’équation différentielle 2x y e . Représenter les solutions pour des
x
valeurs initiales différentes.

Exercice 3
Résoudre l’équation différentielle suivante :
Y''-3Y' +2Y =X-1
Y(0)=1
Y'(0)=5
Donner les solutions dans l’intervalle [0..10].

Exercice 4
1/ Résoudre les équations différentielles suivantes :
a/ 4 x. y ''  x   y '  x   y  0
b/ 5 y '  x   y  x  sin  x   y  x  sin  2 x   0
4

2/ Résoudre le système différentiel :

 x ' t   x  t   2 y  t   z  t 

 y ' t   2x  t   4 y  t   2z  t 

 z ' t   x  t   2 y  t   z  t 

Exercice 5
Résoudre le système suivant :
x'(t)=-y(t)+z(t)
y'(t)=x(t)-z(t)
z'(t)=-x(t)+y(t)

Tracer la courbe correspondant au cas {x(0) = y(0) = 0; z(0)=3}

Montrer que toutes les trajectoires solutions sont planes.

________________________________________________________________________ 64
 Corrigé des exercices
Exercice 1
> restart: eq:=x*diff(y(x),x)+y(x)=1/(1-x);
dsolve donne une solution générale de l'équation, mais sans préciser l'intervalle sur lequel elle est
valide. On constate de plus que Maple n'a pas choisi l'expression la plus simple: ln(1-x) serait plus
approprié,et permettrait de se passer des complexes.
> dsolve({eq,y(-1)=a},y(x));

On va donc utiliser une formulation un peu plus "naturelle"...

> f:=(ln(1-x)+c)/x;

Regardons maintenant à quelle condition la fonction peut être continue:

> limit(f,x=0,left);
> c:=0;

Il faut poser c:=0. Est-ce suffisant ?

f est continue. Il faudrait en outre vérifier la continuité de sa dérivée en 0 (En fait, f'(0)=-1/2)
> limit(f,x=0);

Pour finir, on peut tracer la solution obtenue :

> plot(f,x=-5..1);

Exercice 2

Pour représenter les solutions, il suffit de donner une valeur initiale à notre fonction. Pour cela, nous
créons une séquence qui va contenir les équations des courbes à tracer puis les représenter.

Exercice 3
> restart :
> eq :=diff (y(x),x$2)-3*diff(y(x),x)+2*y(x)=x-1 ;
________________________________________________________________________ 65
> dsolve({eq, D(y)(0)=5,y(0)=1}, y(x)) ;
> A := rhs(%) ;

>plot(A,x=0..10) ;

Exercice 4
> eq1:=4*x*diff(y(x),x$2)+diff(y(x),x)=0 ;
> sol1:=dsolve(eq1,y(x)) ;
> restart : readlib(isolate) ;
> eq2 :=5*diff(y(x),x)-y(x)*sin(x)+y(x)^4*sin(2*x)=0 ;
> sol2 :=dsolve(eq2,y(x)) ;
> sol2 :=isolate(sol2,y(x)) ;
> allvalues(sol2) ;

> restart :
> eq1 :=diff(x(t),t)=x(t)+2*y(t)-z(t) ;
> eq2 := diff(y(t),t)=2*x(t)+4*y(t)-2*z(t) ;
> eq3 := diff(z(t),t)=-x(t)-2*y(t)+z(t) ;
> dsolve({eq1,eq2,eq3},{x(t),y(t),z(t)} );

Exercice 5
> restart :
On commence par définir les trois équations du système.
> eq1:=diff(x(t),t)=-y(t)+z(t):
eq2:=diff(y(t),t)=x(t)-z(t):
eq3:=diff(z(t),t)=-x(t)+y(t):
Le cas général: dsolve convient parfaitement.
> dsolve({eq1,eq2,eq3},{x(t),y(t),z(t)});

Pour la solution vérifiant les conditions initiales indiquées dans l'énoncé, il suffit d'ajouter les dites
C.I. dans l'ensemble d'équations fourni en argument à dsolve.

> sol:=dsolve({eq1,eq2,eq3,x(0)=0,y(0)=0,z(0)=3},{x(t),y(t),z(t)});

plot3d étant fait pour tracer des surfaces, il lui faut deux paramètres indépendant. Cela dit, les
solutions ne dépendent pas de s, paramètre un peu inutile...

> plot3d(subs(sol,[x(t),y(t),z(t)]),t=0..2*Pi,s=0..1);

> expr:=diff(x(t),t)+diff(y(t),t)+diff(z(t),t):

Pour x, y et z solutions de l'équation différentielle, expr est nulle, donc la somme des trois
composantes est constante: on a bien une équation de plan.

> expr1:=subs({eq1,eq2,eq3},expr);

________________________________________________________________________ 66
 Séance 10 et Séance 11

Révision générale : résolution de problèmes et leur programmation

Remarque : les problèmes de révision peuvent être choisis parmi les exercices et problèmes
proposés dans les paragraphes complément d’exercices du support « NOTE DE COURS DE
MAPLE, TRAVAUX PRATIQUES avec exercices corrigés » ou autres.

________________________________________________________________________ 67
 Séances 12 [9]
Application aux systèmes linéaires :
ELECTROCINETIQUE

1- Position du problème
Soit le circuit électrique suivant :
R1 = 5 kOm
I3
N
I1
I2

I II R3 = 5 kOm
E =6 V I
R = 10 kOm
2

A B
M

On se propose de calculer les intensités des courants qui parcourent les différentes branches du
circuit.

2- Système d’équations

En appliquant la loi des mailles, pour les mailles I et II, et la loi des nœuds, pour le nœud N,
on obtient le système d’équations algébriques suivant :

R1 I1 +R2 I 2 =E

R2 I 2 −R3 I3 = 0 A
 I1 −I 2 −I3 = 0

Ce système peut se réécrire sous forme matricielle. Soit :
R1 R2 0 I1  E 
 0 R −R I =0  B
1 − 2
1 −1
3
I2  
 0

  
3

2- Résolution avec Maple

Utiliser Maple pour trouver les courants I1, I2 et I3. Ecrire une procédure courant qui permet
de trouver les courants I1, I2 et I3.

ZONE MAPLE

1- Utilisation de l’instruction solve

On va tout d’abord utiliser l’instruction solve qui permet de résoudre les équations
algébriques et les systèmes d’équations algébriques. La syntaxe minimale est solve(eq) (cas d’une
seule équation) ou solve(syst) (cas d’un système) s’il n’y a pas d’ambiguïté concernant la (les)
inconnue(s) de l’équation (système). Dans le cas contraire, il faut la/les préciser. La syntaxe devient
alors solve(eq, x) et solve(syst,{x1,x,2x…xN}). Appliquons pour la résolution du sytème A.
________________________________________________________________________ 68
> restart;
> eq1:=R1*I1+R2*I2=E;
eq2:=R2*I2-R3*I3=0;
eq3:=I1-I2-I3=0;

> syst:={eq1,eq2,eq3};

> solution:=solve(syst,{I1,I2,I3});

> R1:=5;R2:=10;R3:=5;E:=6;evalf(solution,3);

2- Utilisation de l’instruction linsolve

Essayons maintenant de résoudre le problème en utilisant l’équation matricielle B. La
commande linsolve(A,B) résout l’équation matricielle A*X=B par rapport à X. On déclare pour
cela :
• Un vecteur intensities (correspondant à X) et contenant les 3 intensités inconnues
• Un vecteur generators (correspondant à B) et contenant les 3 tensions membres
droits du système.
• Une matrice resistors (correspondant à A) et qui contient les coefficients
(résistances) du système.
En plus, on se propose d’écrire la solution sous forme d’une procédure qu’on appellera courant.
Les paramètres éventuels de la procédure sont R1, R2, R3 et E.
> restart:
Il ne faut pas oublier de faire appel à la bibliothèque linalg qui contient les outils nécessaires de
l'algèbre linéaire
> with(linalg):
Warning, new definition for norm
Warning, new definition for trace
Texte de la procédure:
> courant:=proc(E,R1,R2,R3)
resistors:=matrix(3,3,[R1,R2,0,0,R2,-R3,1,-1,-1]);
generators:=vector([E,0,0]);
intensities:=linsolve(resistors,generators);
end;
Appel de la procédure
> courant(6.,5.,10.,5.);

________________________________________________________________________ 69
 Séance 13 [9]

PENDULE SIMPLE
1. Enoncé du problème.
Soit une pendule simple constituée d’un fil inextensible et sans masse de longueur l auquel est
suspendue une masse ponctuelle m. La position de la masse est repérée par l’angle θ que fait le fil
avec la verticale.
A l’instant t = 0, la pendule est lancée depuis sa position d’équilibre θ0 = 0 à la vitesse initiale θ0 =
v (en rad.s-1 ).
On cherche à déterminer les variations de θ en fonction du temps t pour différentes valeurs de v.

2. Résolution à l’aide de Maple.

a) Equation différentielle.
Etablir l’équation différentielle vérifiée par θ(t) pour un fil de longueur 1 m .
Ecrire cette équation en Maple en précisant la valeur de g ( 9,81 m.s-2 ).
b) Résolution de l’équation différentielle.
Demander à Maple la résolution de l’équation précédente, compte tenu des conditions initiales (θ0 =
0 et θ0 = v).
Au vu de la réponse retournée par Maple, on choisit de résoudre numériquement l’équation (option
numeric) pour avoir une solution approchée et de tracer la fonction θ(t) obtenue (odeplot) en faisant
varier les vitesses initiales v entre 1 et 10 m.s-1 (instruction seq). On pourra stocker les dessins
obtenus dans une table (faire une boucle for dont le corps contiendra un dessin[i] :=odeplot...) puis
utiliser la fonction display du module plots avec ou sans l’option insequence=true.

c) Interprétation physique.
On remarque l’existence d’une vitesse seuil qui fait passer d’une solution périodique (oscillations) à
une solution où q est strictement croissante (tour complet).
Donner, à l’aide des graphes obtenus, un encadrement de vseuil .
Monter par le calcul que la valeur cherchée est vseuil = 2 g = 6,28 m.s-1 et conclure.
II. ZONE MAPLE
1. Equation différentielle.
> restart:g:=9.81:
> eq:=diff(diff(theta(t),t),t)+g*sin(theta(t))=0;

2. Résolution directe.
> syst:={eq,D(theta)(0)=v,theta(0)=0};

>dsolve(syst,theta(t));

________________________________________________________________________ 70
Remarquez ici que Maple ne donne pas une solution de l'équation. En gros, il donne la solution
comme étant l'intégrale de l'équation différentielle et ceci est évident. En fait, quand Maple ne
parvient pas à résoudre une équation analytiquement il retourne la démarche à suivre pour la
résoudre.
Essayant maintenant de simplifier le problème en considérant que l'angle θ est suffisamment faible
pour avoir sin(θ)= θ. Il vient que :

> eq:=diff(diff(theta(t),t),t)+g*theta(t)=0;

Résolution directe.
> syst:={eq,D(theta)(0)=1,theta(0)=0};

> sol1:=dsolve(syst,theta(t));

> assign(sol1):plot(theta(t),t=1..10);

Essayons maintenant de faire intervenir un facteur de frottement visqueux (µ*v) dans l'équation.
Physiquement, ceci veut dire avoir une oscillation amortie de la pendule.

________________________________________________________________________ 71
> restart:eq2:=diff(diff(theta1(t),t),t)+mu*diff(theta1(t),t)+g*theta1(t)=0;

> syst2:={eq2,D(theta1)(0)=1,theta1(0)=0};

> sol2:=dsolve(syst2,theta1(t));

> mu:=1:g:=9.81:
> assign(sol2):plot(theta1(t),t=1..10);

A ce stade, vous pouvez examiner l’influence des conditions initiales et du coefficient de frottement
sur la solution de l’équation.
Revenons maintenant à l’équation initiale c.a.d avec le sin(θ) et essayons de la résoudre
numériquement. Maple offre la possibilité d’utiliser quelques algorithmes de résolution numérique
des équations différentielles (Voir le Help). On donne ici seulement la continuité (syst étant supposé
défini comme plus haut)
3. Résolution numérique.
> L:=[seq(dsolve(syst,theta(t),type=numeric),v=1..10)]:
> for i to 10 do dessin[i]:=odeplot(L[i],[t,theta(t)],-3..3,numpoints=100,color=black) od:
> with(plots):
> display([seq(dessin[i],i=1..10)]);

________________________________________________________________________ 72
En comptant ci dessus les valeurs de v dans le sens décroissant, on détermine la vitesse limite
comprise entre 6 et 7 m.s-1, ce qui est conforme à la valeur attendue : v = 6,28 m.s-1 .

________________________________________________________________________ 73
Références

[1] B.BEN BEYA, M.BRICHNI Faculté des Sciences de Tunis (Bibiographie :1. Maple V en
classes prépas, Philippe RAMBACH, ellipses. 2. Algorithmes cours et exercices résolus, S. Boutin
et S. Tormento, Réal. 3. Jack-Michel Cornil.Philippe Testud Maple introduction raisonnée à l’usage
de l’étudiant, de l’ingénieur et du chercheur Springer, 4. Cours d’algorithmique (classe de 1ère année
MP et PC, institut préparatoire aux études d’ingénieur de Tunis).

[2] HAMMAMI Mohamed IPEI El Manar

[3] HAMMAMI Leila IPEIN
[4] CHAABENE Sinda IPEI El Manar
[5] DARRAGI Soumeya IPEST
[6] MAHJOUBI Med Ali IPEI Monastir
[7] NIGROU Meriem IPEIM Manar
[8] ELLOUMI Mourad IPEIS
[9] ZIDI Zouheir ISSAT Gabès

Ce document a été élaboré par une commission constituée de représentants de tous les
établissements des cycles préparatoires aux études d’ingénieur et dont la coordination a été
assurée par Monsieur Kamel BEN RHOUMA (ENSI).

________________________________________________________________________ 74