Systèmes linéaires : méthode de Gauss : cours, méthodes et exercices corrigés
Système linéaire et écriture matricielle, représentation en listes de listes, opérations élémentaires sur les lignes, élimination et remontée, choix du pivot partiel, comparaison à zéro des flottants, coût en opérations ; propre à la TSI2 marocaine : pivot total, Gauss-Jordan pour l'inverse, déterminant, numpy.linalg.solve.
- 17méthodes
- 35exercices corrigés
- 3problèmes
- 19pièges
- 41figures
Ce que tu sauras faire
Un circuit électrique, un bilan de matière ou une structure discrétisée mènent à un système de équations linéaires à inconnues. Pour , on le résout à la main ; pour , il faut un algorithme sûr, écrit proprement, dont on connaît le coût et les limites. Ce chapitre construit cet algorithme, la méthode de Gauss, fonction par fonction.
- écrire un système sous la forme et le représenter en Python par une liste de listes ;
- copier une matrice sans créer d'alias, et savoir si une fonction modifie ses arguments ;
- résoudre un système triangulaire par remontée ou par descente ;
- écrire les trois opérations élémentaires sur les lignes ;
- dérouler l'élimination de Gauss à la main, puis l'écrire en Python de façon modulaire ;
- choisir le pivot : pivot nul, pivot petit, pivot partiel, comparaison à zéro des flottants ;
- tester une résolution et justifier sa complexité en ;
- reconnaître une matrice de forme particulière qui coûte moins cher.
L'essentiel : Le cadre Extrait gratuit
- Système de Cramer : avec carrée inversible ; une solution unique. Le programme se limite à ce cas.
- Matrice triangulaire supérieure : pour ; inversible si et seulement si sa diagonale n'a aucun zéro.
- Pivot : le coefficient diagonal qui sert à annuler la colonne sous la diagonale.
- Pivot partiel : le coefficient de plus grande valeur absolue dans la colonne , sur la ligne et en dessous.
- Méthode directe : nombre d'opérations connu d'avance ; exacte en arithmétique exacte, approchée en flottants à cause des arrondis.
Une méthode du chapitre Extrait gratuit
L'énoncé décrit un système par ses équations, ou par une situation physique (circuit, mélange, structure), et demande de construire et , ou la matrice augmentée.
La ligne de contient les coefficients de l'équation , rangés dans l'ordre des inconnues ; une inconnue absente a le coefficient 0. A est une liste de listes, B une liste de nombres, et la matrice augmentée ajoute au bout de la ligne (cours, sections 1.2, 2.1 et 2.3).
- Fixer l'ordre des inconnues et l'écrire :
- Réécrire chaque équation avec toutes les inconnues à gauche, dans cet ordre, et le terme constant à droite.
- Recopier les coefficients ligne par ligne, avec des 0 pour les inconnues absentes.
- Écrire les coefficients en flottants.
- Contrôler la taille : lignes de coefficients.
« On range les inconnues dans l'ordre . La ligne de A contient les coefficients de l'équation et B[i] son second membre. »
A = [[1.0, 1.0, 1.0], [2.0, -1.0, 1.0],
[1.0, 2.0, -1.0]]
B = [6.0, 3.0, 2.0]
Le système , , . La troisième équation se réécrit : son coefficient en est . On construit aussi la matrice augmentée.
A = [[1.0, 1.0, 1.0], [2.0, -1.0, 1.0],
[1.0, 2.0, -1.0]]
B = [6.0, 3.0, 2.0]
M = [A[i] + [B[i]] for i in range(3)]
print(M)
print(resoudre(A, B))
Le programme affiche :
[[1.0, 1.0, 1.0, 6.0], [2.0, -1.0, 1.0, 3.0], [1.0, 2.0, -1.0, 2.0]]
[0.9999999999999998, 2.0000000000000004, 3.0000000000000004]
La solution est aux arrondis près ; on vérifie dans la troisième équation : .
- Oublier de passer une inconnue à gauche : la ligne de
Aest fausse. - Mélanger l'ordre des inconnues d'une ligne à l'autre.
- Omettre les coefficients nuls : la ligne n'a plus la bonne longueur.
- Écrire
A[i].append(B[i])sur la matrice du système :Aest modifiée et n'est plus carrée.
Exercices 1, 21, 22 et 23.
Un exercice corrigé Extrait gratuit
Le circuit ci-dessous est alimenté par un générateur de tension idéal V. Les résistances valent Ω, Ω, Ω, Ω, Ω et Ω. On note , , les courants de maille, orientés dans le sens horaire.
- Écrire la loi des mailles pour chaque maille, et en déduire le système sous la forme avec .
- Écrire en Python la matrice
A, le second membreB, puis la matrice augmentéeM, de 3 lignes et 4 colonnes, sans modifierA. - Résoudre le système avec
resoudreet interpréter le résultat.
- Méthode 1 : une ligne par maille, une colonne par courant.
- Dans une branche commune à deux mailles, le courant vaut la différence des deux courants de maille.
- Pour la matrice augmentée, copie chaque ligne avant d'y ajouter le terme de
B.
Parcours chaque maille dans le sens de son courant. Une résistance propre à la maille donne un terme en , une résistance commune avec une maille voisine donne . Range ensuite les coefficients de , , dans cet ordre, et place la force électromotrice à droite.
Question 1. La maille 1 contient , et , la maille 2 contient , et , la maille 3 contient , et :
Avec les valeurs de l'énoncé :
Questions 2 et 3.
On recopie chaque ligne de A avant d'y ajouter le terme de B : sans la copie, append allongerait aussi les lignes de A.
R1, R2, R3 = 10.0, 20.0, 10.0
R4, R5, R6 = 30.0, 10.0, 20.0
E = 12.0
A = [[R1 + R2, -R2, 0.0],
[-R2, R2 + R3 + R4, -R4],
[0.0, -R4, R4 + R5 + R6]]
B = [E, 0.0, 0.0]
M = []
for i in range(3):
ligne = A[i].copy()
ligne.append(B[i])
M.append(ligne)
print(M)
I = resoudre(A, B)
print(I)
Le programme affiche :
[[30.0, -20.0, 0.0, 12.0], [-20.0, 60.0, -30.0, 0.0], [0.0, -30.0, 60.0, 0.0]]
[0.5684210526315788, 0.2526315789473684, 0.1263157894736842]
Les valeurs exactes sont A, A et A, soit environ A, A et A : le dernier chiffre affiché diffère seulement à cause des arrondis des flottants. Les trois courants sont positifs : ils circulent dans le sens choisi. On a , ce que donne directement la troisième équation (). Le courant dans vaut A, du haut vers le bas. Contrôle : , à l'arrondi près.
Une ligne par maille, une colonne par inconnue, et l'ordre des inconnues fixé une fois pour toutes. La matrice augmentée se construit sur des copies des lignes. Voir la méthode 1.
Le cours détaillé, toute la fiche « L'essentiel », 17 méthodes, 19 pièges corrigés, la carte mentale, 35 exercices corrigés, 3 problèmes de concours, les fiches à mémoriser et l'assistant qui répond à tes questions. Ce chapitre est offert : il s’ouvre en entier avec un compte d’essai gratuit.
Ouvrir l'essai gratuitVoir les offresPlan du cours
- 1. Le problème : un système linéaire carré
- 1.1 Un exemple concret : un circuit à trois mailles
- 1.2 L'écriture matricielle
- 1.3 Pourquoi ni les formules de Cramer ni l'inverse
- 1.4 D'où viennent les grands systèmes
- 2. Représenter un système en Python
- 2.1 Une matrice en liste de listes
- 2.2 Créer une matrice nulle et l'identité
- 2.3 La matrice augmentée
- 2.4 Copier une matrice
- 2.5 Les mêmes objets avec
numpy
- 3. Les systèmes triangulaires
- 3.1 Le cas facile
- 3.2 La remontée
- 3.3 La descente
- 4. Les opérations élémentaires
- 4.1 Trois opérations qui ne changent pas les solutions
- 4.2 Les opérations en Python
- 4.3 Coût
- 5. Le principe de l'élimination de Gauss
- 5.1 Un exemple à la main
- 5.2 L'algorithme en deux phases
- 5.3 Le coefficient de la transvection
- 5.4 Terminaison et correction
- 6. Le choix du pivot
- 6.1 Le pivot nul
- 6.2 Le pivot petit
- 6.3 Le pivot partiel
- 6.4 Comparer un flottant à zéro
- 6.5 Le pivot partiel ne change pas la complexité
- 7. L'algorithme complet, écrit de façon modulaire
- 7.1 Le découpage en fonctions
- 7.2 Le code
- 7.3 Trace d'exécution
- 7.4 Tester
- 7.5 Une variante : ramener chaque pivot à 1
- 8. Complexité
- 8.1 Compter les opérations de la triangularisation
- 8.2 Ce que cela veut dire
- 8.3 Vérifier par la mesure
- 8.4 Profiter de la forme de la matrice
- 9. Pour aller plus loin
- 10. Le pivot total
- 11. Gauss-Jordan et le calcul de l'inverse
- 12. Le déterminant par l'élimination
- 13.
numpyet la fonctionsolve- 13.1 Les fonctions de
numpy.linalg - 13.2 La méthode de Gauss écrite avec
numpy
- 13.1 Les fonctions de
Les méthodes du chapitre
Chaque méthode est une fiche : quand l'utiliser, le rappel de cours, les étapes, la rédaction attendue sur la copie, un exemple traité, les erreurs à éviter.
- Écrire un système sous la forme AX = B et le représenter en Python
- Copier une matrice sans alias et dire si une fonction modifie ses arguments
- Résoudre un système triangulaire par remontée ou par descente
- Écrire les trois opérations élémentaires en place, sur A et sur B
- Dérouler l'élimination à la main sur un 3 × 3
- Chercher l'indice du pivot partiel
- Assembler l'algorithme complet de façon modulaire
- Tester une résolution
- Traiter un pivot nul ou presque nul
- Justifier la complexité de la méthode de Gauss
- Vérifier une complexité par la mesure
- Adapter l'élimination à une matrice de forme particulière
- Compléter ou corriger un code de Gauss d'un sujet
- Appliquer le pivot total
- Inverser une matrice par Gauss-Jordan
- Calculer un déterminant par l'élimination
- Utiliser numpy et numpy.linalg.solve sans piège
Les exercices corrigés
Chaque exercice a ses indications, sa correction rédigée et ce qu'il faut en retenir.
Application directe (14)
- Un circuit à trois mailles mis en équations
- La matrice identité, sans alias
- Descente et remontée
- Transvection et échange de lignes
- L'élimination à la main
- Où est le pivot partiel
- Un système qui commence par un zéro
- Nul ou presque nul
- Compter les opérations
- Trouver l'erreur dans la recherche du pivot
- Alias et copie d'une matrice
- Deux systèmes sans toucher aux données
- Le premier pivot total
- L'inverse par Gauss-Jordan
Entraînement (16)
- Un pivot cherché au-dessus de la diagonale
- Le pivot partiel à la main
- La résolution complète, écrite en modules
- Un petit pivot et trois chiffres significatifs
- Le décompte exact de la triangularisation
- La cartographie d'un calculateur d'injection
- Mesurer le temps de calcul
- Un solveur 2 × 2 sans fonction interne
- Un circuit à quatre mailles
- Trois espèces, trois longueurs d'onde
- Gauss sur la matrice augmentée
- Quatre remontées fausses
- Une matrice non inversible en flottants
- Plusieurs seconds membres
- Le déterminant d'une grille binaire
- numpy sans piège
Approfondissement (5)
- Une chaîne de masses et sa matrice tridiagonale
- Pivot partiel ou premier pivot non nul
- Une résolution exacte en fractions
- Une matrice sensible aux données
- Gauss-Jordan pour résoudre un système
Les problèmes de concours
Des extraits de sujets réels, corrigés en entier, avec la durée conseillée et les méthodes mobilisées.
- Éléments finis : résoudre le système d'une poutre
- Inverser une matrice par élimination
- La décomposition LU par l'algorithme de Doolittle
Comment y accéder
Ce chapitre fait partie des chapitres offerts : il s'ouvre en entier avec un compte d'essai gratuit pour les filières dont il est l'un des premiers chapitres. Créer un compte d'essai ou se connecter. Pour l'accès complet et les tarifs, vois les offres.