Algèbre linéaire

Salut tout le monde.

A consommer avec modération!

Je vous propose un programme d’algèbre pour résoudre un système linéaire de N équations à N inconnues.
Mais à quoi ça pourrait servir ?
Ça ne sert à rien mais ça sert dans tous les domaines de la science !
Ça sert aussi à avoir mal au crâne ! Donc c’est utile !
Ça sert aussi à résoudre des problèmes ludiques : en voici deux !

1) Paul est deux fois plus âgé que Jean, et à eux deux ils ont trente ans de plus que Laurent.
Dans cinq ans, l’âge de Laurent sera double de celui de Jean.
Trouvez leurs âges actuels.

2) Quatre frères ont travaillé et ont récolté une somme de 550 Euros.
Pierre, l’ainé, demande à avoir deux fois plus que son frère cadet Paul.
Jacques et Bruno, jumeaux, demandent à avoir la même somme chacun.
Enfin Paul estime devoir recevoir une fois et demie la somme allouée aux deux jumeaux.
Quel est le résultat du partage ?

Mise en équation

Pour le 1er problème :
Appelons P,J,L les âges de Pierre, Jean et Laurent : ce sont les inconnues du problème.
La 1ere proposition s’écrit : P = 2*J
La seconde se résume par : P + J = 30 + L
Enfin, la 3ème égalité est équivalente à : L + 5 = 2*(J + 5), ou L = 2*J + 5

Nous obtenons le système de 3 équations à 3 inconnues suivant, en ramenant P, J et L à gauche du signe =, les constantes étant laissées à droite, dans le second membre :
P -2*J = 0
P + J - L = 30
-2*J + L = 5
Si on écrit les coefficients des inconnues sous forme d’un tableau à 3 lignes et 3 colonnes, on obtient :
1 -2 0
1 1 -1
0 - 2 1

Pour soumettre ce système à notre programme, entrez successivement les valeurs :
1; -2; 0; 0
1; 1; -1; 30
0; -2; 1; 5

La solution est :
P = 70
J = 35
L = 75

Pour le 2ème problème :

Décidons d’appeler :
x1 le gain de Pierre
x2 le gain de Paul
x3 le gain de Jackes
x4 le gain de Bruno

Nous savons dès le départ que :
x1 + x2 + x3 + x4 + x5 = 550
Puis
x1 = 2*x2
x3 = x4
x2 = 1.5*(x3 + x4)
autrement dit :
x1 + x2 + x3 + x4 = 550
x1 -2*x2 = 0
x3 – x4 = 0
x2 -1.5*x3 – 1.5*x4 =0

Voici donc un système de 4 équations à 4 inconnues
Entrez successivement les valeurs :
1 ;1 ;1 ;1 ;500
1 ; 1 ; 0 ; 0 ; 0
0 ; 0 ; 1 ; -1 ; 0
0 ; 1 ; -1.5 ; -1.5 ; 0

Le programme vous donne la solution :
x1 = 300 ; x2 = 150 ; x3 = 50 ; x4 = 50

Code:: ' ******************************************************************************
'
' SYSTEME.BAS
'
' Résolution d'un système de N équations à N inconnues par la methode de GAUSS
'
' Par PAPYDALL
'
' ******************************************************************************

Init() : Saisie() : Triangulation() : Resolution() : Affichage() : Fin()
end
' ******************************************************************************
SUB Init()
DIM n%,gain,zz,maxi
gain = 1000000 : zz = .5/gain
print " *****************************************************************"
print " * Résolution d'un système linéaire de N équations à N inconnues *"
print " *****************************************************************"
print
END_SUB
' ******************************************************************************
' Introduction des données
SUB Saisie()
DIM_LOCAL r$,i%,j%
repeat
repeat
r$ = message_input$("Entrer le nombre d'équations"," Ce nombre doit être un entier > 1 : N = ","")
until numeric(r$) = 1
until val(r$) > 1 and val(r$) = int(val(r$))
n% = val(r$)
DIM equation(n%-1,n%)
for i% = 1 to n%
print " EQUATION n°" ; i% ;" : " ;
for j% = 1 to n%
repeat
r$ = message_input$("Entrer le coefficient de X"+str$(j%),"X"+str$(j%)+" = ","")
until numeric(r$) = 1
equation(i%-1,j%-1) = val(r$) : print equation(i%-1,j%-1) ; " ";
next j%
repeat
r$ = message_input$("Entrer la valeur du second membre","Second membre = ","")
until numeric(r$) = 1
equation(i%-1,n%) = val(r$) : print equation(i%-1,n%)
next i%

END_SUB
' ******************************************************************************
' Triangulation de la matrice avec pivotage partiel
SUB Triangulation()
dim_local i%,j%,i1%,k%,aa,bb,cc,ex,pivot
for j% = 0 to n%-2
i1% = j% : maxi = abs(equation(j%,j%))
for i% = j%+1 to n%-1
aa = abs(equation(i%,j%))
if aa >= maxi then i1% = i% : maxi = aa
next i%
if maxi < zz
message "Ce système n'admet pas de solution bien définie!" : Fin()
end_if
for k% = j% to n%
ex = equation(j%,k%) : equation(j%,k%)= equation(i1%,k%) : equation(i1%,k%) = ex
next k%
pivot = equation(j%,j%)
for k% = j% to n% : equation(j%,k%) = equation(j%,k%) / pivot : next k%
for i% = j%+1 to n%-1
bb = equation(i%,j%)
for k% = j% to n% : equation(i%,k%) = equation(i%,k%) - bb * equation(j%,k%) : next k%
next i%
next j%
cc = equation(n%-1,n%-1)
if abs(cc) < zz
message "Ce système n'admet pas de solution bien définie!" : Fin()
end_if
equation(n%-1,n%) = equation(n%-1,n%) / cc : equation(n%-1,n%-1) = 1
END_SUB
' ******************************************************************************
' Calcul des inconnues
SUB Resolution()
dim_local i%,j%
for i% = n%-2 to 0 step -1
for j% = n%-1 to i%+1 step -1
equation(i%,n%) = equation(i%,n%) - equation(i%,j%) * equation(j%,n%)
next j%
next i%
END_SUB
' ******************************************************************************
' Affichage de la solution
SUB Affichage()
dim_local i%,x
print : print : print " SOLUTION" : print : print
for i% = 1 to n%
x = int(gain * (equation(i%-1,n%) + zz)) / gain
print " * X";i%;" = ";X
next i%
END_SUB
' ******************************************************************************
SUB Fin()
end
END_SUB
' ********************************** FIN **********************************

EDIT :
En général, un système de N équations à N inconnues admet une solution unique.
Cependant, il arrive parfois qu’un système en possède une infinité, si certaines équations sont redondantes.
Il arrive aussi qu’un système soit irrésoluble, en particulier si certaines équations sont contradictoires.

EXEMPLE :
x1 + x2 = 2
2*x1 + 2*x2 = 4
Ces 2 équations sont redondantes car la 2ème se déduit simplement de la 1ère en multipliant par 2.
Elles peuvent donc se résumer à x1 + x2 = 2 qui comporte une infinité de solutions ( x1 = 0 et x2 = 2 ; ou x1 = x2 = 1 ; ou encore x1 = -7.5 et x2 = 9.5 etc.)

En revanche, le système :
x1 + 2*x2 = 1
x1 + 2*x2 = 0
est impossible car x1 + 2*x2 ne peut valoir 0 et 1 en même temps : aucune solution n’existe dans cet exemple.

Dans tous les cas de figure, cette absence de solution unique est détectée par le programme qui affiche le message "Ce système n'admet pas de solution bien définie!"

Après quelques jours d'absence, je vois que pappydall torture toujours les panoramiciens...

Algèbre linéaire 3d-moqueur-rire-3

PS: Pour ceux que ça qui sont intéressés, j'ai un stock de Doliprane ! Laughing

Papydall, je pense que ce serait plsu sympa d'avoir une saisie dans une fenêtre avec des cases de saisie sous la forme:

Equation n°1: [ ] X1 + [ ] X2 + [ ] X3 + [ ] X4 = [ ]
Equation n°2: [ ] X1 + [ ] X2 + [ ] X3 + [ ] X4 = [ ]
Equation n°3: [ ] X1 + [ ] X2 + [ ] X3 + [ ] X4 = [ ]
Equation n°4: [ ] X1 + [ ] X2 + [ ] X3 + [ ] X4 = [ ]

Avec redimensionnement de la fenêtre si nécessaire
Avec contrôle du remplissage de données avant de lancer la résolution
(Et placement du Focus sur la première case non remplie)

Rebienvenue Ygeronimi.
Je suis content de ton retour. Ton humour me manque.
J’espère que tu es en forme .
Quant au Doliprane, je croix que personne n’en a besoin : la preuve aucune manifestation, aucun commentaire !
Peut-être qu’ils sont encore sous la torture cérébrale ! Algèbre linéaire Triste

@Jicehel

GOOD IDEA!

Ygeronimi est de retour, Ygeronimi le fera!

NB: Pour moi, coder un algorithme est plus simple que de le bien présenter!

@Ygeronimi
Tu peux m'envoyer un tube de Doliprane parce que le Papydall me rappelle que je suis un cancre en Math.. et comme j'essai, néanmoins, de suivre, j'ai bobo à ma tête confused

Tiens...! en v'là même deux !
Et c'est des 1000 !...

Algèbre linéaire Mdr-mort-de-rire-284923

Rassure toi, Jean Claude : On est tous cancre en quelque chose, à quelques exceptions près (pour ne pas offenser les sensibles).
Mais dans le cas de figure, ni le doliprane aimablement offert par Ygeronimi ni un autre comprimé ne peuvent apporter un quelconque soulagement. Algèbre linéaire Lol

Il suffit de cliquer sur le programme et sans lâcher le bouton (de la souris s’entend !) le faire glisser jusqu’à l’icône représentant une corbeille (et qui s’appelle justement corbeille et se trouve en général sur le bureau à gauche) et de lâcher la souris : la guérison est immédiate !

Pour que YGeronimi fasse, il faut qu'il comprenne ce qu'il fait .
Et là... YGeronimi nage, ou plutôt coule...
Laughing

La fin du monde n’aura pas lieu le 21/12/2012 c.à.d. dans mois d’une heure.
Je posterais donc une nouvelle version de mon programme Algèbre linéaire.
Sinon, espérons que dans l’au-delà, on trouvera un Forum Panoramic ! Algèbre linéaire 00102

Bizarre... on a pas entendu Paco cette année... scratch

Il n'a pas osé la refaire ... bon bonne fin du monde à tous ...

Comme promis, voici la nouvelle version du programme d’algèbre linéaire.
En début de lancement, le programme vous demande le nombre d’équations N : entrez une valeur entière égale ou supérieure à 2.
Le programme vérifie et refuse toute saisie incorrecte.
Néanmoins, il n’impose pas une valeur maximale pour N.

L’algorithme utilisé peut, au moins en théorie, résoudre un système quelconque d’équations.
Pour des questions de commodité (affichage à l’écran, saisie des différents paramètres, etc.), donnez pour N une valeur raisonnable (comprise entre 2 et 10).
Mais rien ne vous empêche de résoudre des systèmes de 30 ou 50 équations !

Après avoir entré N, le programme affiche les différentes équations avec tous les paramètres à zéro.
Vous pouvez modifier toutes les valeurs ou seulement quelques unes.
Cliquez sur le bouton Valider : si un ou plusieurs paramètres sont invalides, le programme vous le signale par un message.
Cliquez sur le bouton Résoudre pour lancer la résolution.
Si le système est indéterminé ou impossible le programme vous le signale.
Si tout est correct, le programme affiche instantanément la solution.
En cliquant sur OK, vous pouvez garder votre système en modifiant certaines valeurs (ou toutes) et demander une autre exécutions (n’oubliez pas de valider avant).
Le bouton Quitter vous permet de … (devinez !).

Code:: ' ******************************************************************************
'
' SYSTEME.BAS
'
' Résolution d'un système de N équations à N inconnues par la methode de GAUSS
'
' Par PAPYDALL
'
' ******************************************************************************

go()
end
' ******************************************************************************
SUB go()
dim i%,j%,n% ,i1,j1 ,r$ ,erreur%
form 9997 : top 9997,100 : left 9997,400 : height 9997,500 : width 9997,600
print_target_is 9997 : caption 9997,"Algèbre linéaire par PAPYDALL"
application_title "Algèbre linéaire par PAPYDALL"
print_locate 100,50 : font_bold 9997
print " Résolution d'un système linéaire de N équations à N inconnues" : print
print " Ce programme peut résoudre un système linéaire de N équations à N inconnues."
print " Pour une question de commodité, la valeur de N peut être choisie entre 2 et 20"
print " N = 10 est déjà beaucoup !"
print r$ :print
print " L'algorithme utilisé peut résoudre même un système de plusieurs centaines d'équations."
print " Mais soyons raisonnables !"
hide 0
repeat
repeat
r$ = message_input$("Entrer le nombre d'équations"," Ce nombre doit être un entier > 1 : N = ","")
until numeric(r$) = 1
until val(r$) > 1 and val(r$) = int(val(r$))
n% = val(r$)
hide 9997 : show 0
DIM equation(n%-1,n%),gain,zz,maxi
gain = 1000000 : zz = .5/gain
label valider ,resol,quit
width 0,1250 : height 0,700
caption 0,"Système linéaire de "+str$(n%)+" équations à "+str$(n%) +" inconnues"
container 1 : top 1 ,20 : left 1,20 : width 1,1200 : height 1,48 * n% : hide 1
button 2 : top 2,600: left 2,700: caption 2,"Valider" : on_click 2,valider
for i% = 9000 to 9000+n%-1
alpha i% : parent i%,1 : top i%,30 : left i%,110+50*(i%-9000) :height i%,20
width i%,20 : caption i%," X"+str$(i%-8999)
next i%
alpha i% : parent i%,1 : top i%,30 : left i%,100+50*(i%-9000) :height i%,20
width i%,20 : caption i%,"Second membre"
for i% = 3 to n%+2
alpha i% : parent i%,1 :top i%,20*i%-10 :left i%,10
if i% < 12
caption i%,"EQUATION N°0" + str$(i%-2)
else
caption i%,"EQUATION N°" + str$(i%-2)
end_if
for j% = 1 to n%
edit 100*(i%+2)+j% : parent 100*(i%+2)+j%,1 : top 100*(i%+2)+j%,20*i%-10
left 100*(i%+2)+j%,50+50*j%:text 100*(i%+2)+j%,"0"
equation(i%-3,j%-1) = val(text$(100*(i%+2)+j%))
next j%
edit 100*(i%+2)+j% : parent 100*(i%+2)+j%,1 : top 100*(i%+2)+j%,20*i%-10
left 100*(i%+2)+j%,50+50*j%:width 100*(i%+2)+j%,70: text 100*(i%+2)+j%,"0"
equation(i%-3,n%) = val(text$(100*(i%+2)+j%))
next i%
button 9999 : top 9999,600 : left 9999,600 : caption 9999,"Résoudre"
on_click 9999,resol : inactive 9999
button 9998 : top 9998,600 : left 9998,500 : caption 9998,"Quitter"
on_click 9998,quit
show 1
END_SUB
' ******************************************************************************
valider:
active 9999
for i1 = 1 to n%
for j1 = 1 to n%
if numeric(text$(100*(i1+4)+j1)) = 1
equation(i1-1,j1-1) = val(text$(100*(i1+4)+j1))
else
message "Veuillez saisir une valeur numérique correcte" : return
end_if
next j1
if numeric(text$(100*(i1+4)+j1)) = 1
equation(i1-1,j1-1) = val(text$(100*(i1+4)+j1))
else
message "Veuillez saisir une valeur numérique correcte" : return
end_if
equation(i1-1,n%) = val(text$(100*(i1+4)+j1))
next i1
return
' ------------------------------------------------------------------------------
' Triangulation de la matrice avec pivotage partiel
SUB Triangulation()
dim_local i%,j%,i1%,k%,aa,bb,cc,ex,pivot
erreur% = 0
for j% = 0 to n%-2
i1% = j% : maxi = abs(equation(j%,j%))
for i% = j%+1 to n%-1
aa = abs(equation(i%,j%))
if aa >= maxi then i1% = i% : maxi = aa
next i%
if maxi < zz
message "Ce système n'admet pas de solution bien définie!"
erreur% = 1 : exit_sub
end_if
for k% = j% to n%
ex = equation(j%,k%) : equation(j%,k%)= equation(i1%,k%) : equation(i1%,k%) = ex
next k%
pivot = equation(j%,j%)
for k% = j% to n% : equation(j%,k%) = equation(j%,k%) / pivot : next k%
for i% = j%+1 to n%-1
bb = equation(i%,j%)
for k% = j% to n% : equation(i%,k%) = equation(i%,k%) - bb * equation(j%,k%) : next k%
next i%
next j%
cc = equation(n%-1,n%-1)
if abs(cc) < zz
message "Ce système n'admet pas de solution bien définie!"
erreur% = 1 :exit_sub
end_if
equation(n%-1,n%) = equation(n%-1,n%) / cc : equation(n%-1,n%-1) = 1
END_SUB
' ******************************************************************************
' Calcul des inconnues
resol:
Triangulation()
for i% = n%-2 to 0 step -1
for j% = n%-1 to i%+1 step -1
equation(i%,n%) = equation(i%,n%) - equation(i%,j%) * equation(j%,n%)
next j%
next i%
if erreur% = 0 then Affichage()
return
' ******************************************************************************
' Affichage de la solution
SUB Affichage()
dim_local i%,x
show 9997 : print_target_is 9997
print : print : print " SOLUTION" : print : print
for i% = 1 to n%
x = int(gain * (equation(i%-1,n%) + zz)) / gain
print " * X";i%;" = ";X
next i%
message string$(70," ") : hide 9997
END_SUB
' ******************************************************************************
quit:
terminate
' ********************************** FIN **********************************

REMARQUE :
1/ Bien sûr, vous pouvez modifier le programme, le conserver, le diffuser et même le jeter à la corbeille !!
2/ Ygeronimi possède encore son stock de Doliprane!

Je préfère largement cette façon de saisir, c'est beaucoup plus rapide Wink

Pour la coder, ça m’a presque donné envie de faire une demande à Ygeronimi pour qu’il m’expédiât un tube de son stock !!

» Programmation linéaire
» Les pentaminos
» MÉTHODE du plus petit carré (régression linéaire)