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

________________________________________________________________________ 2
 Rapport général sur les équations différentielles premier et second ordre
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’ENTREES 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:=r eadstat("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éé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("exp1=%d\n exp2=%d\n expr3=%d",a+b,a*b,a-b);
exp1=9
exp2=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
end if;

________________________________________________________________________ 4
 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:
> 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`)
end if;
♦ La boucle while
Exécute une suite d'instructions, tant que la condition est vraie.
while condition do ... end do;
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 end do:
`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 ... end do;
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 end do:
`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 end do:
`somme `=somme;
for variable in expression do .. end do;
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`) end if
end do;
§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.
Exemples :
> f:=x->exp(x)-x;
> f:=(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 proc;
Exemple 6:

________________________________________________________________________ 5
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)
description "calcule le plus grand de 2 entiers positifs";
option `Copyright (c) 2001 A.Le Stang`;
if u<v then v else u end if;
end proc;
> 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 end do;
end proc;
> 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 end do;
y
end proc;
> div(48); On obtient en effet successivement : 48,24,12,6,3.
> div(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 end if;
end proc;
> 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)) end if
end proc;
> 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
________________________________________________________________________ 6
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;
♦ 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 :
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[~]:=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;
end do;
end do:
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
Un tableau carré T à n lignes et n colonnes étant donné,

________________________________________________________________________ 7
 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 :
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 Informatique Algèbre Anglais …

NOM
Emna MOYENNE 10 02 15 14 …
Iskander 08 05 02 14
Syrine 12 11 17 15
Manel 14 12 18 15
Malek
…..

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 end if;
end proc;
max2(a,max2(b,c));
end proc;

max3 := proc (a ::posint, b ::posint, c::posint) end proc

local max2 ;
max2 := proc (x::posint, y::posint) if y < x then x else y end if end proc ;
max2 ( a , max2 ( b , c ) )
> 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))
end if;
end if;
end proc;

________________________________________________________________________ 9
 second_degre := proc (a , b , c)
local δ ;
if a = 0 then error "a doit être non nul"
else
δ := b ^2 − 4×a ×c;
if δ < 0 then print( `pas de solution` )
elif δ = 0 then print( `racine double `, x = −1/2×b /a )
else print( `2 racines distinctes `, x = 1/2×( −b − sqrt ( δ ) )/a ,
x = 1/2×( −b + sqrt ( δ ) )/a )
end if
end if
end proc
> 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]
end do:
print(s):
end proc;
diagonale2 := proc (T , n )
local i, s;
s := 0 ; for i to n do s := s + T [ i, n + 1 − i ] end do ; print( s )
end proc
> a:=array([[1,1,5],[0,2,0],[0,4,3]]);
 1 1 5
 
a :=  0 2 0
 0 4 3
 
> 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;

________________________________________________________________________ 10
od;
print(V);end;

transfert := proc (M )
local i, j, k, L , C , V ;
k := 1;
V := vector ( rowdim( M )×coldim( M ) ) ;
for i to rowdim( M ) do end proc
for j to coldim( M ) do V [ k ] := M [ i, j ] ; k := k + 1 end do
end do ;
print( V )
> M:=matrix(2,3,[a,b,c,c,d,e]);
M := 
a b c

 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="):
end do:

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:
end if:
end do:
s:=x[j]: x[j]:=x[k]: x[k]:=s:

end do:
for i from 1 to n do
x[i]:=x[i]
end do;
n := 5
x=-1;
x=2;
x=14;
x=124;
x=-154;
x1 := 124

________________________________________________________________________ 11
 x2 := 14
x3 := 2
x4 := -1
x5 := -154

Problème 1
Méthode
Nous ultrasons 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
moyegen, moycla : réels
début
(* saisie des différents tableau*)
POUR inmat ← 1 à 10
Ecrire (`` entrer le nom de la matière numéro : ``, inmat)
Lire(mat(indmat)
FPOUR
POUR indele ← 1 à 32
Ecrire(``entrer le nom de l’étudiant numéro : ``, indele)
Lire(nom(indele)
POUR indmat ← 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 ← moyge,+moyenne(indele,indmat)
FPOUR
moycla ← moycla+moygen
FPOUR
Ecrire(``moyenne générale de la classe ``,moycla/32
Fin algorithme.

________________________________________________________________________ 12
 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);
fonction dérivée dérivée 1ere x
2
+ 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
fonction dérivée n ième x → −2
1
+ 2
x
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
∂ x + 1
2
x + 1
= 2−
∂x x 2
>diff(f(x),x,...,x) ; ou x

________________________________________________________________________ 13
 diff(f(x),x$n) ; => dériver > diff(f(x), x$2);
l'expression f(x) n fois par 1
2
x + 1
rapport à x −2 + 2
x 3
Remarque : $ est l'opérateur de x
répétition.
Déterminer la > int(f(x), x) ; > Int(f(x),x) = int(f(x),x) ;
primitive de ⌠ 2

l’expression f(x) x + 1 1 2
 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 -1
par défaut (variable globale x + x
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→ ∞ et x→ ∞

________________________________________________________________________ 14
d) Représenter la courbe avec ses asymptotes pour x compris entre -5 et 5.
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 de 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 le 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.

________________________________________________________________________ 15
 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 variables
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 asymptotique, courbes etc.). Un résumé des fonctions les
plus utilisées a été 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 variables Exemple
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) ;
ième
fonction dérivée n 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) ∂
> diff(g(x,y),x,y$n) ; => x sin( y ) = − sin( y )
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

________________________________________________________________________ 16
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) ;
entre a et b > Int(g(x,y), x=a..b) ; ou x
⌠
Int(g(x,y), y=a..b) ; => forme  x sin( y ) dy = − 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) ; >
en a > limit(g(x,y),y=a,dir) ; Limit(g(x,y),x=0,left)=limit(g(x,y),x=0,left);
Remarque : dir (optionel) est lim x sin( y ) = 0
la direction = left, right, real, x → 0-
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.

________________________________________________________________________ 17
 Séance 4 [4]
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 …………………………………………

________________________________________________________________________ 18
 >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) ;
…………………………………………
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 :

1. Définir le polynôme P = (3x2y + xy2 - x - 2y +xy +2)(x + 1)

2. Développer P
3. Ordonner les termes de P selon xy
4. Donner les coefficients des termes xy et x2y2
5. Regrouper les termes en x2y et en xy2

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 :

________________________________________________________________________ 19
 bx+c dx+e f g
G := a + + + +
x2 + 1 2 x + 1 ( x + 1 )2
( x2 + 1 )
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.

Correction :
Exercice 1 :

> restart;F:=(6*x^2+18*x-24)/(x^2+2);
6 x 2 + 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 x2 − 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 +1
2 2 x + 1 ( x + 1 )2
( x2 + 1 )

________________________________________________________________________ 20
 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 x4 + 4 a x3 + 3 a x2 + 2 a x + 2 b x3 + 2 c x2 − x6 + e + f + f x4 + 2 f x2 + f x + g x 4
+ 2 g x2 + 2 f x3 + f x5 + 2 d x2 + e x 2 + 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;

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 x4 + 4 a x3 + 3 a x2 + 2 a x + 2 b x3 + 2 c x2 − x6 + e + f + f x4 + 2 f x2 + f x + g x 4
+ 2 g x2 + 2 f x3 + f x5 + 2 d x2 + e x 2 + 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
6 −x − x
x 4 2 1 4
=1+ + − +
2
x +1
2 2 x + 1 ( x + 1 )2
( x2 + 1 ) ( x + 1 ) 2 ( x2 + 1 )

________________________________________________________________________ 21
 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 Re(nombre complexe) >Re((2-I) * (3+5*I)) ;
complexe
Partie imaginaire d’un Im(nombre complexe) >Im((2-I) * (3+5*I)) ;
nombre complexe
Evaluation d’un nombre evalc( nombre complexe) >evalc(2^(1+I)) ;
complexe
Conjugé d’un nombre conjugate(nombre complexe) >conjugate((3+5*I)*(1-2*I)) ;
complexe
Argument d’un nombre argument(nombre complexe) >argument(3+I) ;
complexe
Conversion en coordonnées polar(nombre complexe) >polar(3+4*I) ;
polaires
Transformation géométrique conformal(f(z),z=zi..zf) ; > f:=z->z^3; with (plots):
dans le plan complexe conformal(f(z),z=-1-I..1+I);

________________________________________________________________________ 22
II. Exercices d’application :
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. 5 + 5 I
Exercice 3 :
Trouver le modules 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 :
a. x − x ( 1 + a + I a ) + a x ( 1 + I + I a ) − I a = 0
3 2 2

b. ( 1 − I ) z = ( 1 + I ) z + 4
2+I 1−2I
c.
• x −I=0
6

• 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 + z + 1 = 0 , alors le conjugué de z
2

satisfait aussi cette équation.

Exercice 6:
z+2I
Soit f une fonction définie sur C par f(z)=
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 ).

________________________________________________________________________ 23
Correction

Exercice1 : donner la forme cartèsienne des nombres complexes suivants:

> restart;c:=evalc((1-I)^n);
cos n π  − I e sin n π 
( 1/2 n ln( 2 ) ) 1 ( 1/2 n ln( 2 ) ) 1
c := e
 4  4 
> evalc((-2*(cos(Pi/4)-I*sin(Pi/4)))/(3*(cos(Pi/6)+I*sin(Pi/6))));
2 + I  2 
1 1 1 1
− 2 3+ 2 3+
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);
a := polar 12, π 
2
 3 
> b:=convert(-1+sqrt(3)*I,polar);
b := polar 2, π 
2
 3 
> c:=convert(Pi,polar);
c := polar( π, 0 )
> d:=convert(-7+24*I,polar);
d := polar 25, −arctan  + π 
24
 7 
> e:=convert(4/5+(3/5)*I,polar);
e := polar 1, arctan  
3
 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);

________________________________________________________________________ 24
 t :=  − + 5 + I 2 5 + 5  −I ,  − − 5 + I 2 5 − 5  −I ,
1 1 1 1 1 1
 4 4 4   4 4 4 
 1 1
5 − I 2 5 − 5  −I ,  − +
1 1 1
5 − I 2 5 + 5  −I ,
1
 − −
 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: ");
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="

________________________________________________________________________ 25
  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="
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
   − 1 − 1 5  2 + 1 5 − 5  +  1 5 − 5 +  1 + 1 5  2  ,
polar  8 8   4 8 8  
   4     


 1 5 − 5 + 1 + 1 5  2  
    
 4  8 8  
 + π 
arctan
  − 1 − 1 5  2 + 1 5 − 5  
    
 8 8  4  

________________________________________________________________________ 26
 
 2 2
   − 1 − 1 5  2 − 1 5 − 5  +  − 1 5 − 5 +  1 + 1 5  2  ,
polar  8 8    4 8 8  
   4     


 1 5 − 5 + 1 + 1 5  2  
−    
 4  8 8  
 + π 
arctan
  − 1 − 1 5  2 − 1 5 − 5  
    
 8 8  4  

 2 2
   1 5 − 1  2 − 1 5 + 5  +  − 1 5 + 5 +  1 − 1 5  2  ,
polar 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  

polar 1, − π 
1
 4 

polar 1, π 
3
 4 
Exercice 5: montrer que si z = a+bi (a,bappartiennent à 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));

________________________________________________________________________ 27
 {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
> with(plots):conformal(f(z),z=-1-2*I..1+I);

________________________________________________________________________ 28
 Séance 6 [5]
Algèbre linéaire :
Partie A : Fonctions prédéfinies
Pour charger un package, il faut utiliser la commande (with). Comme pour tout, 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.
1°>M 1:=matrix(nbl,nbc,[liste des
éléments de ma matrice]) ;
M1:=matrix(3,3,[1,2,7,8,0,1,-5,6,2]);
2°>M2 :=matrix([[éléments ligne
[ 1 2 7]
1],[ éléments linne 2],[ éléments
[ 8 0 1]
ligne 3]]) ;
[-5 6 2]
3°>f :=(i,j)->i+j-1 ;
>M2:=matrix([[1,0,-1], [2,0,1 ],
M3 :=matrix(nbl,nbc,f) ;
[1,0,-2]]);
(où nbl, nbc et f désignent
[1 0 -1]
respectivement le nombre de ligne,
[2 0 1]
le nombre de colonnes, et une
[1 0 -2]
fonction à deux variables (i et j)
>> f:=(i,j)->i+j-1;
désignant l’indice ligne et l’indice
Entrée d’une > M3:=matrix(3,3,f);
colonne
matrice: [1 2 3]
Il existe différentes 4°>Matrice à coefficients
[2 3 4]
manières pour indéterminés
[3 4 5]
déclarer une matrice, >M4:=matrix (nbl,nbc,[]);
>M4:=matrix(3,2,[]);
nous présentons les #[] désigne la liste vide
[m[1, 1] m[1, 2] ]
principales: 5°>matrice diagonale
[m[2, 1] m[2, 2] ]
>M5 :=diag(éléments en diagonale)
[m[3, 1] m[3, 2] ]
>M5:=diag(3,2,1);#matrice diagonale
[3 0 0]
[0 2 0]
[0 0 1]
Remarque
ou encore
> M1; # en tapant la lettre
>M51:=diag(2$3);
seulement la matrice ne s'affiche
[2 0 0]
pas, il faut utiliser la commande
[0 2 0]
evalm
[0 0 2]
> evalm(M1);

> V:=vector([liste des coordonnées > V:=vector([1,2,-1]);

Entrée d’un vecteur:
Un vecteur est une du vecteur]); V := [1, 2, -1]

________________________________________________________________________ 29
matrice ligne
Opérations
élémentaires sur les
matrices
1.Somme de deux >matadd(M1,M2);
matrices. >matadd(M1,M2); [ 2 2 6]
# deux possibilités >evalm(M1&+M2); [10 0 2]
[-4 6 0]

2.Produit de deux >evalm(M1&*M2);

matrices. >multiply(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]

3.Multiplication > scalarmul(M1,3);

d'une matrice par > scalarmul(Matrice, scalaire); [ 3 6 21]
un scalaire. [ 24 0 3]
[-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(M1) ;
>inverse(matrice) ; # si la matrice
[-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 ]
.
Soit la matrice N
>N:=matrix(3,3,[18,42,12,3,-,6,-9,-
Rang d’une matrice >rank(matrice); 21,-6]);
>rank(N) ;
2
Trace d’une >trace(N) ;
>trace(matrice) ;
matrice 3

________________________________________________________________________ 30
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,
d’une matrice multiplicité et enfin une base du 4]}], [12, 1, {[-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(matrice, 21,-6]]);
Jordan ‘matrice_de _passage’) ; > N1:=jordan(N,'P');
Maple peut calculer
la forme réduite de [-9 0 0]
Jordan. On peut de N1 := [ 0 12 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/3 2 -5/3]
[-1/3 0 1/3 ]
[-1/3 -1 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.
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

________________________________________________________________________ 31
 7- Donner les valeurs propres, les vecteurs propres puis le polynôme caractéristique de
A.
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 -1] [1 0 1 0]
[0 0 0 0]
A1:= [1 -1 0 -1]
A2 := [1 0 0 1]
[1 -1 -1 0]
[0 1 0 0]
3A1 A1+A2
[0 3 3 3] [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]

________________________________________________________________________ 32
Exercice 2
1) A:=matrix(3,3,[1,-1,2,-2,1,0,1,1,3]);
2)> TA:=transpose(M);
[ 1 -1 2]
A := [-2 1 0]
[ 1 1 3]
[ 1 -2 1]
TA := [-1 1 1]
[ 2 0 3]
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(M); eigenvects(M); charpoly(M,x);

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

________________________________________________________________________ 33
 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');
[1 0 0 0]
[0 -3 0 0]
K := [0 0 1 0]
[0 0 0 1]
> evalm(Q);
[11/4 1/4 2 1]
[1/4 -1/4 0 0]
[5/4 -1/4 1 0]
[5/4 -1/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]

________________________________________________________________________ 34
 [ 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
> 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 +1/2*116 , 71/58* 174 n-13/58 116 n ,
n 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;

________________________________________________________________________ 35
Partie II : Programmation
Exercice 1
Ecrivez un programme calculant la multiplication de deux matrices C=AxB. Utiliser la
p
formule mathématique C ij = ∑ Aij Bkj .
k =1

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 don être assez simple. On sait que la matrice C va être 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;

________________________________________________________________________ 36
multmat := proc (A, B )
local C , i, j, k;
C := matrix( rowdim( A ), coldim( B ) ) ;
for i to rowdim( C ) do for j to coldim( C ) do
C[ i, j ] := 0;
for k to coldim( A ) do C[ i, j ] := C [ i, j ] + A[ i, k ]×B [ k, j ] end do
end do
end do ;
RETURN ( C )
end proc
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
 
A :=  1 4
 2  9 6
 3 B := 
1 2
 C := C 
17 10

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 structure 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.
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

________________________________________________________________________ 37
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.

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

________________________________________________________________________ 38
 .
0+0+...+unnxn = cn

4 Finalement la solution est obtenue par simple substitution :

( −∑k = i+1nuikxk+ci)
xi = (i = n,n−1,...,2,1) (6)
rii
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.

________________________________________________________________________ 39
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

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

________________________________________________________________________ 40
 ---------------------------------------

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

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 :

________________________________________________________________________ 41
 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 :

1. Procédure SAISIE (N : entier)

var
i,j : entier
Début
pour i  1 jusqu’à N faire
écrire (« donner l’élément d’indice »,i, »du vecteur b »)
lire (b[i])
fin pour
pour i  1 jusqu’à N faire
pour j 1 jusqu’à 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
i1
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 i jusqu’à N faire
p  -A1 [j,i] / A1[i,i]
b1[j]  b1[j] + p*b1[i]
pour m  i+1 jusqu’à N faire

________________________________________________________________________ 42
 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 en décroissant jusqu’à 1 faire
S0
Pour j  i+1 jusqu’à 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  1 jusqu’à 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

________________________________________________________________________ 43
Programmation avec Maple de la méthode de GAUSS [7]

Enoncé :
Soient les deux matrices A et B suivantes, il s’agit de résoudre le système linéaire A.X = B
par la méthode de GAUSS.
2 0 4 -4  -4
   
4 2 -1 -1  1
A :=   B :=  
6 0 1 -3  -3
   
4 -4 4 3  -1
   
Principe de résolution :
1. Créer la matrice C concaténation des deux matrices A et B

2. Transformer la matrice C en une matrice triangulaire en utilisant les étapes suivantes:

a. Utiliser la première ligne pour éliminer les éléments de la première colonne
b. Utiliser la deuxième ligne modifiée pour éliminer les éléments de la deuxième
colonne
c. etc.

Correction :
> som:=proc(M,i,j,a,n)
local k;
for k from 1 to n do
M[j,k]:= M[j,k]+a*M[i,k];
od;
return(evalm(M));
end proc;
som := proc (M, i, j, a, n)
local k;
for k to n do M[ j, k ] := M[ j, k ] + a×M[ i, k ] end do ; return evalm( M )
end proc
> M:=matrix(3,3,[1,-2,0,1,3,-2,4,1,0]);

1 -2 0
 
M := 1 3 -2
 
4 1 0
> som(M,2,1,-1,3);

________________________________________________________________________ 44
 0 -5 2
 
1 3 -2
 
4 1 0
> permut:=proc(M,i,j,n)
local k,x;
for k to n do
x:= M[i,k];
M[i,k]:=M[j,k];
M[j,k]:=x;
od;
return(evalm(M));
end proc;
permut := proc (M, i, j, n)
local k, x;
for k to n do x := M[ i, k ] ; M[ i, k ] := M[ j, k ] ; M[ j, k ] := x end do ;
return evalm( M )
end proc
> permut(M,1,2,3);
1 3 -2
 
0 -5 2
 
4 1 0
> N:=matrix(3,1,[2,0,-3]);
 2
 
N :=  0
 
 -3
> with (linalg):
> C:=augment(M,N);
1 3 -2 2
 
C := 0 -5 2 0
 
4 1 0 -3
> elim:=proc(M,N,n)
local i,j,k,C,a;
C:=augment(M,N);
for i to n-1 do
for j from i+1 to n do
a:=-C[j,i]/C[i,i];
som(C,i,j,a,n+1);
od;
od;
return(evalm(C));
end proc;

________________________________________________________________________ 45
elim := proc (M, N, n)
local i, j, k, C, a;
C := augment( M, N ) ;
for i to n − 1 do
for j from i + 1 to n do a := −C[ j, i ]/C[ i, i ] ; som( C, i, j, a, n + 1 ) end do
end do ;
return evalm( C )
end proc
> elim(M,N,3);
1 3 -2 2
 
0 -5 2 0
 
0 18
 0 -11
 5 
> A:=matrix(4,4,[2,0,4,-4,4,2,-1,-1,6,0,1,-3,4,-4,4,3]);
2 0 4 -4
 
4 2 -1 -1
A := 
6 0 1 -3
 
4 -4 4 3
 
> B:=matrix(4,1,[-4,1,-3,-1]);
 -4
 
 1
B :=  
 -3

 -1

> E:=elim(A,B,4);
Z:=delcols(E,5..5);
T:=delcols(E,1..4);
2 0 4 -4 -4
 
0 2 -9 7 9
E :=  
0 0 -11 9 9

0 0 7 7
 0
2 0 4 -4
 
0 2 -9 7
Z :=  
0 0 -11 9

0 0 7
 0
 -4
 
 9
T :=  
 9

 7

> back:=proc(A,B,n)
local i, C;
C:=matrix(n,1);
C[n,1]:=B[n,1]/A[n,n];

________________________________________________________________________ 46
for i from n-1 by -1 to 1 do
C[i,1]:=(B[i,1]-sum(A[i,k]*C[k,1],k=i+1..n))/A[i,i];
od;
return(evalm(C));
end proc;
back := proc (A, B, n)
local i, C;
C := matrix( n, 1 ) ;
C[ n, 1 ] := B[ n, 1 ]/A[ n, n ] ;
for i from n − 1 by -1 to 1 do
C[ i, 1 ] := ( B[ i, 1 ] − sum( A[ i, k ]×C[ k, 1 ], k = i + 1 .. n ) )/A[ i, i ]
end do ;
return evalm( C )
end proc
> back(Z,T,4);
 0
 
 1
 
 0
 1


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.

________________________________________________________________________ 47
 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 suites 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 suites 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 :

________________________________________________________________________ 48
 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 IN, on pose :
Vn = Un – a avec a : un 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 pour répondre à cette question
b. la programmation

________________________________________________________________________ 49
 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 : ∏ V( k ) , en utilisant
k=0

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
∏  3 k + 1  = 185.3703704
2
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

________________________________________________________________________ 50
 4
( -1 )k
∑ 1 + 2 k = .8349206
k=0
(n + 1)  3   5 1  3 1 
( -1 )  + n   Ψ + n  − Ψ + n  
1
lim π −
1  2   4 2  4 2  = 1
n→0 4 2 3+2n
> 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);
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)

s := 2  
1
+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);

________________________________________________________________________ 51
 6
> V:=unapply(U(n)-a,n);
n

V := n → 6   + 6 − a
1
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
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
∑  3 4k + 3 − 3 4  = 112.
8 2 16 ( k − 1 )
k=0

2.b/

________________________________________________________________________ 52
> 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);
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"

________________________________________________________________________ 53
 Séance 9 [8]

Equations différentielles ET Systèmes différentiels

Tableau récapitulatif

Fonction Rôle Exemple

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

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

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

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

conditions initiales},
{fonction},numeric) ;
odeplot(fonction, [var1,
var2], min1..max1,
option) ;
numérique des dsolve({equa ,y(0)=0},y(x),numeric) ;
équations
différentielles
Représentation de equa :=diff(y(x),x)+sin(y(x))=x ;
la fonction (après s:=dsolve({equa ,y(0)=0},y(x),numeric) ;
résolution with(plots);
numérique) 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) ;

________________________________________________________________________ 54
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

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.

________________________________________________________________________ 55
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.
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 du pendule pesant (on se rappelle que cette
équation s’écrit pour de petits mouvements θ&&( t ) + ω 2θ ( t ) = 0 )

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érentielle 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.

________________________________________________________________________ 56
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 :

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.

________________________________________________________________________ 57
 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 . Représenter les solutions
Résoudre dans IR l’équation différentielle +2x y−e
∂x
pour des 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 :

________________________________________________________________________ 58
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.

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.

________________________________________________________________________ 59
Exercice 3
> restart :
> eq :=diff (y(x),x$2)-3*diff(y(x),x)+2*y(x)=x-1 ;
> 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.

________________________________________________________________________ 60
> 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);

________________________________________________________________________ 61
 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.

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

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

I1
I2

E =6 V
I II R3 = 5 kOm
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 noeux, pour la
noeux N, on obtient le système d’équations algébriques suivant :

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

2- Résolution avec Maple

Utiliser Maple pour trouver les courants I1, I2 et I3. le système 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) si il n’y a pas d’ambiguïté concernent
la (les) inconnue(s) de l’équation (système). Dans le cas contraire, il faut la/les préciser. La
________________________________________________________________________ 63
syntaxe devient alors solve(eq, x) et solve(syst,{x1,x,2x…xN}). Appliquons pour la résolution
du sytème A.
> 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 éventuelles de la procédure sont R1, R2, R3 et E.
> restart:
Il ne faut pas oublier d'appeler la bibliothèque linalg qui contient les outilles nécessaire 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;
Warning, `resistors` is implicitly declared local
Warning, `generators` is implicitly declared local
Warning, `intensities` is implicitly declared local

________________________________________________________________________ 64
Appelle de la procédure
> courant(6.,5.,10.,5.);

________________________________________________________________________ 65
 Séance 13 [9]

PENDULE SIMPLE
1. Position du problème.
Soit un pendule simple constitué 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, le pendule est lancé 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));

________________________________________________________________________ 66
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 et évident. En faite quant
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);

________________________________________________________________________ 67
Essayant maintenant de maître un facteur de frottement visqueux (µ*v) dans l'équation.
Physiquement, ceci veut dire avoir une oscillation amortie de la pendule

> 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 là vous pouvez examiner l’influence des conditions initiales et du coefficient de

frottement sur la solution de l’équation.
Revenant maintenant à l’équation initiale c.a.d avec le sin(θ) et essayant de la résoudre
numériquement. En fait 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):

________________________________________________________________________ 68
> display([seq(dessin[i],i=1..10)]);

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 .

________________________________________________________________________ 69
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).

________________________________________________________________________ 70