Vous ne trouvez pas de réponse à votre problème ? Alors posez la question dans le forum. Souvenez-vous qu'il n'y a jamais de question bête, mais rester dans l'ignorance parce que l'on n'ose pas poser une question, ça c'est une erreur !

MÉTHODE D'ÉLIMINATION DE GAUSS-JORDAN, ET DU PIVOT DE GAUSS POUR SYSTÈMES D'ÉQUATIONS LINÉAIRES À 3 INCONNUES


Information sur la source

Description

"En mathématiques, l'élimination de Gauss ou l'élimination de Gauss-Jordan, nommé en hommmage à Carl Friedrich Gauss et Wilhelm Jordan est un algorithme de l'algèbre linéaire pour déterminer les solutions d'un système d'équations linéaires, pour déterminer le rang d'une matrice ou pour calculer l'inverse d'une matrice carrée inversible. Lorsqu'on applique l'élimination de Gauss sur une matrice, on obtient sa forme échelonnée réduite." d'après wikipédia (http://fr.wikipedia.org/wiki/Élimination de Gauss-Jordan). Je n'aurais pas mieux dit ;)

 

Source

  • /*
  • * Created by SharpDevelop.
  • * User: yanngeffrotin@gmail.com
  • * Date: 16/12/2005
  • * Time: 19:08
  • */
  • using System;
  • namespace Pivot_de_Gauss
  • {
  • class MainClass
  • {
  • public static void Main(string[] args)
  • {
  • Console.WriteLine("Méthode du pivot de Gauss avec systèmes d'équations linéaires");
  • Console.WriteLine("Licence publique générale GNU");
  • /*
  • Sommaire :
  • 1 - Déclaration des variables
  • 2 - Saisie des nombres
  • 3 - Affichage des équations saisies
  • 4 - Méthode d'élimination des inconnues de Gauss - Jordan
  • 5 - Affichage des résultats
  • 6 - Triangulation du système (pivot de Gauss)
  • 7 - Calcul des résultats
  • 8 - Affichage des solutions
  • 9 - Encore des équations ?
  • */
  • // 1 - Déclaration des variables
  • // déclaration des connues
  • string [] Tnom={" ","a","b","c","d"} ;
  • // déclaration des tableaux de 4 valeurs flottantes
  • // tableau principal
  • float [,] Tnb = new float[4+1,4+1];
  • // a=0
  • float [] Tnb2 = new float[4+1];
  • float [] Tnb3 = new float[4+1];
  • // a=0 et b=0
  • float [] Tnb4 = new float[4+1];
  • // resultats
  • float [] Tnb5 = new float[4+1];
  • // entier : nombre d'équations, compteur
  • int cpt, cpt2 ;
  • // flotant : les ratios
  • float ratio, ratio2, ratio3 ;
  • // booléen
  • bool val ;
  • // texte
  • string texte ;
  • do
  • {
  • Console.WriteLine(" ");
  • Console.WriteLine("Exemple : ") ;
  • Console.WriteLine("+2x-3y+1z = -4");
  • Console.WriteLine("-4x+6y+3z = 28");
  • Console.WriteLine("-6x+5y-2z = 6");
  • // 2 - Saisie des nombres
  • Console.WriteLine(" ");
  • Console.WriteLine("Les saisies");
  • for(cpt=1;cpt<=3;cpt++)
  • {
  • for(cpt2=1;cpt2<=4;cpt2++)
  • {
  • Console.WriteLine("L" + cpt + ", " + Tnom[cpt2] + " : " );
  • Tnb[cpt,cpt2] = Int32.Parse(Console.ReadLine());
  • }
  • }
  • // 3 - Affichage des équations saisies
  • Console.WriteLine(" ");
  • Console.WriteLine("Les équations");
  • for(cpt=1;cpt<=3;cpt++)
  • {
  • Console.WriteLine("{ "+Tnb[cpt,1]+"x + "+Tnb[cpt,2]+"y + "+Tnb[cpt,3]+"z = "+Tnb[cpt,4]);
  • }
  • // 4 - Méthode d'élimination des inconnues de Gauss - Jordan
  • // calcul des ratios (M . X = C donc X = C / M)
  • ratio = Tnb[2,1] / (-Tnb[1,1]) ;
  • ratio2 = Tnb[3,1] / (-Tnb[1,1]) ;
  • // Tnb2[1] = ((Tnb[2,1] / (-Tnb[1,1])) * Tnb[1,1]) + Tnb[2,1] ;
  • // remplissage du tableau 2
  • Tnb2[1] = (Tnb[1,1] * ratio) + Tnb[2,1] ;
  • Tnb2[2] = (Tnb[1,2] * ratio) + Tnb[2,2] ;
  • Tnb2[3] = (Tnb[1,3] * ratio) + Tnb[2,3] ;
  • Tnb2[4] = (Tnb[1,4] * ratio) + Tnb[2,4] ;
  • // remplissage du tableau 3
  • // on enlève les x
  • Tnb3[1] = (Tnb[1,1] * ratio2) + Tnb[3,1] ;
  • Tnb3[2] = (Tnb[1,2] * ratio2) + Tnb[3,2] ;
  • Tnb3[3] = (Tnb[1,3] * ratio2) + Tnb[3,3] ;
  • Tnb3[4] = (Tnb[1,4] * ratio2) + Tnb[3,4] ;
  • // nouveau ratio
  • ratio3 = Tnb3[2] / (-Tnb[1,2]) ;
  • // on enlève les y
  • //(/Tnb3[1]*Tnb3[1] : On enlève les incohérences)
  • Tnb4[1] = ((Tnb[1,1] * ratio3) + Tnb3[1])/Tnb3[1]*Tnb3[1] ;
  • Tnb4[2] = ((Tnb[1,2] * ratio3) + Tnb3[2])/Tnb3[2]*Tnb3[2] ;
  • Tnb4[3] = ((Tnb[1,3] * ratio3) + Tnb3[3])/Tnb3[3]*Tnb3[3] ;
  • Tnb4[4] = ((Tnb[1,4] * ratio3) + Tnb3[4])/Tnb3[4]*Tnb3[4] ;
  • // 5 - Affichage des résultats
  • Console.WriteLine(" ");
  • Console.WriteLine("Elimination des inconnues");
  • Console.WriteLine("{ "+Tnb[1,1]+"x + "+Tnb[1,2]+"y + "+Tnb[1,3]+"z = "+Tnb[1,4]);
  • Console.WriteLine("{ "+Tnb2[1]+"x + "+Tnb2[2]+"y + "+Tnb2[3]+"z = "+Tnb2[4]);
  • Console.WriteLine("{ "+Tnb3[1]+"x + "+Tnb3[2]+"y + "+Tnb3[3]+"z = "+Tnb3[4]);
  • // 6 - Triangulation du système (pivot de Gauss)
  • val=true ;
  • Console.WriteLine(" ");
  • Console.WriteLine("Pivot de Gauss");
  • Console.WriteLine("{ "+Tnb[1,1]+"x + "+Tnb[1,2]+"y + "+Tnb[1,3]+"z = "+Tnb[1,4]);
  • if(Tnb2[1]==0 && Tnb2[2]==0)
  • {
  • Console.WriteLine("{ "+Tnb3[1]+"x + "+Tnb3[2]+"y + "+Tnb3[3]+"z = "+Tnb3[4]);
  • Console.WriteLine("{ "+Tnb2[1]+"x + "+Tnb2[2]+"y + "+Tnb2[3]+"z = "+Tnb2[4]);
  • val=false ;
  • }
  • else
  • {
  • Console.WriteLine("{ "+Tnb2[1]+"x + "+Tnb2[2]+"y + "+Tnb2[3]+"z = "+Tnb2[4]);
  • Console.WriteLine("{ "+Tnb4[1]+"x + "+Tnb4[2]+"y + "+Tnb4[3]+"z = "+Tnb4[4]);
  • }
  • // 7 - Calcul des résultats en sens inverse
  • if(val==true)
  • {
  • Tnb5[3] = Tnb4[4] / Tnb4[3] ;
  • Tnb5[2] = (Tnb2[4] - (Tnb2[3]*Tnb5[3])) / Tnb2[2] ;
  • }
  • else
  • {
  • Tnb5[3] = Tnb2[4] / Tnb2[3] ;
  • Tnb5[2] = (Tnb3[4] - (Tnb3[3]*Tnb5[3])) / Tnb3[2] ;
  • }
  • Tnb5[1] = (Tnb[1,4] - (Tnb[1,3]*Tnb5[3]) - (Tnb[1,2]*Tnb5[2])) / Tnb[1,1] ;
  • // 8 - Affichage des solutions
  • /* |1|0|0|x|
  • |0|1|0|y|
  • |0|0|1|z| */
  • Console.WriteLine(" ");
  • Console.WriteLine("Les solutions");
  • Console.WriteLine("{ x = " + (Tnb[1,4] - (Tnb[1,3]*Tnb5[3]) - (Tnb[1,2]*Tnb5[2])) + " / " + Tnb[1,1] + " = " + Tnb5[1]) ;
  • if(val==true)
  • {
  • Console.WriteLine("{ y = " + (Tnb2[4] - (Tnb2[3]*Tnb5[3])) + " / " + Tnb2[2] + " = " + Tnb5[2]) ;
  • Console.WriteLine("{ z = " + Tnb4[4] + " / " + Tnb4[3] + " = " + Tnb5[3]) ;
  • }
  • else
  • {
  • Console.WriteLine("{ y = " + (Tnb3[4] - (Tnb3[3]*Tnb5[3])) + " / " + Tnb3[2] + " = " + Tnb5[2]) ;
  • Console.WriteLine("{ z = " + Tnb2[4] + " / " + Tnb2[3] + " = " + Tnb5[3]) ;
  • }
  • // 9 - Encore des équations ?
  • do{
  • Console.WriteLine(" ");
  • Console.WriteLine("Encore des équations?(O/N)");
  • texte=Console.ReadLine();
  • texte=texte.ToUpper();
  • }while(texte!="N" && texte!="O") ;
  • }while(texte!="N") ;
  • }
  • }
  • }
/*
 * Created by SharpDevelop.
 * User: yanngeffrotin@gmail.com
 * Date: 16/12/2005
 * Time: 19:08
 */
 
using System;

namespace Pivot_de_Gauss
{
	class MainClass
	{
		public static void Main(string[] args)
		{
			Console.WriteLine("Méthode du pivot de Gauss avec systèmes d'équations linéaires");
			Console.WriteLine("Licence publique générale GNU");

		/*
		Sommaire : 
		1 - Déclaration des variables
		2 - Saisie des nombres
		3 - Affichage des équations saisies
		4 - Méthode d'élimination des inconnues de Gauss - Jordan
		5 - Affichage des résultats
		6 - Triangulation du système (pivot de Gauss)
		7 - Calcul des résultats
		8 - Affichage des solutions
		9 - Encore des équations ?
		*/
			
			
			
			// 1 - Déclaration des variables
			
				// déclaration des connues
					string [] Tnom={" ","a","b","c","d"} ;
				// déclaration des tableaux de 4 valeurs flottantes
					// tableau principal
					float [,] Tnb = new float[4+1,4+1];
					// a=0
					float [] Tnb2 = new float[4+1];
					float [] Tnb3 = new float[4+1];
					// a=0 et b=0
					float [] Tnb4 = new float[4+1];
					// resultats
					float [] Tnb5 = new float[4+1];
					
				// entier : nombre d'équations, compteur
					int cpt, cpt2 ;
				// flotant : les ratios 
					float ratio, ratio2, ratio3 ;
				//	booléen
					bool val ;
				// texte
					string texte ;
			do
			{
				Console.WriteLine(" ");
				Console.WriteLine("Exemple : ") ;
				Console.WriteLine("+2x-3y+1z = -4");
				Console.WriteLine("-4x+6y+3z = 28");
				Console.WriteLine("-6x+5y-2z = 6");
			
			// 2 - Saisie des nombres
					Console.WriteLine(" ");
					Console.WriteLine("Les saisies");
					for(cpt=1;cpt<=3;cpt++)
					{	
						for(cpt2=1;cpt2<=4;cpt2++)
						{
							Console.WriteLine("L" + cpt + ", " + Tnom[cpt2] + " : " );
							Tnb[cpt,cpt2] = Int32.Parse(Console.ReadLine());
						}
					}
			
			// 3 - Affichage des équations saisies
					Console.WriteLine(" ");
					Console.WriteLine("Les équations");
					for(cpt=1;cpt<=3;cpt++)
					{	
						Console.WriteLine("{ "+Tnb[cpt,1]+"x + "+Tnb[cpt,2]+"y + "+Tnb[cpt,3]+"z = "+Tnb[cpt,4]);
					}
				
			// 4 - Méthode d'élimination des inconnues de Gauss - Jordan
					
				// calcul des ratios	(M . X = C donc X = C / M)
					ratio = Tnb[2,1] / (-Tnb[1,1]) ;
					ratio2 = Tnb[3,1] / (-Tnb[1,1]) ;
				
					// Tnb2[1] = ((Tnb[2,1] / (-Tnb[1,1])) * Tnb[1,1]) + Tnb[2,1] ;
					// remplissage du tableau 2
						Tnb2[1] = (Tnb[1,1] * ratio) + Tnb[2,1] ;
						Tnb2[2] = (Tnb[1,2] * ratio) + Tnb[2,2] ;
						Tnb2[3] = (Tnb[1,3] * ratio) + Tnb[2,3] ;
						Tnb2[4] = (Tnb[1,4] * ratio) + Tnb[2,4] ;
				
					// remplissage du tableau 3
						// on enlève les x
						Tnb3[1] = (Tnb[1,1] * ratio2) + Tnb[3,1] ;
						Tnb3[2] = (Tnb[1,2] * ratio2) + Tnb[3,2] ;
						Tnb3[3] = (Tnb[1,3] * ratio2) + Tnb[3,3] ;
						Tnb3[4] = (Tnb[1,4] * ratio2) + Tnb[3,4] ;
						
						// nouveau ratio
						ratio3 = Tnb3[2] / (-Tnb[1,2]) ;
						
						// on enlève les y 
						//(/Tnb3[1]*Tnb3[1] : On enlève les incohérences)
						Tnb4[1] = ((Tnb[1,1] * ratio3) + Tnb3[1])/Tnb3[1]*Tnb3[1] ;
						Tnb4[2] = ((Tnb[1,2] * ratio3) + Tnb3[2])/Tnb3[2]*Tnb3[2] ;
						Tnb4[3] = ((Tnb[1,3] * ratio3) + Tnb3[3])/Tnb3[3]*Tnb3[3] ;
						Tnb4[4] = ((Tnb[1,4] * ratio3) + Tnb3[4])/Tnb3[4]*Tnb3[4] ;
						
				
			
			// 5 - Affichage des résultats	
				
					Console.WriteLine(" ");
					Console.WriteLine("Elimination des inconnues");
					Console.WriteLine("{ "+Tnb[1,1]+"x + "+Tnb[1,2]+"y + "+Tnb[1,3]+"z = "+Tnb[1,4]);
					Console.WriteLine("{ "+Tnb2[1]+"x + "+Tnb2[2]+"y + "+Tnb2[3]+"z = "+Tnb2[4]);	
					Console.WriteLine("{ "+Tnb3[1]+"x + "+Tnb3[2]+"y + "+Tnb3[3]+"z = "+Tnb3[4]);
			

			// 6 - Triangulation du système (pivot de Gauss)
				
					val=true ;
					Console.WriteLine(" ");
					Console.WriteLine("Pivot de Gauss");
					Console.WriteLine("{ "+Tnb[1,1]+"x + "+Tnb[1,2]+"y + "+Tnb[1,3]+"z = "+Tnb[1,4]);
				
					if(Tnb2[1]==0 && Tnb2[2]==0)
					{	
						Console.WriteLine("{ "+Tnb3[1]+"x + "+Tnb3[2]+"y + "+Tnb3[3]+"z = "+Tnb3[4]);
						Console.WriteLine("{ "+Tnb2[1]+"x + "+Tnb2[2]+"y + "+Tnb2[3]+"z = "+Tnb2[4]);
						val=false ;
					}
					else
					{
						Console.WriteLine("{ "+Tnb2[1]+"x + "+Tnb2[2]+"y + "+Tnb2[3]+"z = "+Tnb2[4]);
						Console.WriteLine("{ "+Tnb4[1]+"x + "+Tnb4[2]+"y + "+Tnb4[3]+"z = "+Tnb4[4]);
					}
				
			// 7 - Calcul des résultats en sens inverse

					if(val==true)
					{	
						Tnb5[3] = Tnb4[4] / Tnb4[3] ;
						Tnb5[2] = (Tnb2[4] - (Tnb2[3]*Tnb5[3])) / Tnb2[2] ;
					}
					else
					{
						Tnb5[3] = Tnb2[4] / Tnb2[3] ;
						Tnb5[2] = (Tnb3[4] - (Tnb3[3]*Tnb5[3])) / Tnb3[2] ;	
					}
				
				Tnb5[1] = (Tnb[1,4] - (Tnb[1,3]*Tnb5[3]) - (Tnb[1,2]*Tnb5[2])) / Tnb[1,1] ;
				
			// 8 - Affichage des solutions
				
			    /*   |1|0|0|x|
					 |0|1|0|y|
					 |0|0|1|z|	*/
			
					Console.WriteLine(" ");
					Console.WriteLine("Les solutions");
					Console.WriteLine("{ x = " + (Tnb[1,4] - (Tnb[1,3]*Tnb5[3]) - (Tnb[1,2]*Tnb5[2])) + " / " + Tnb[1,1] + " = " + Tnb5[1]) ;
					
					if(val==true)
					{	
						Console.WriteLine("{ y = " + (Tnb2[4] - (Tnb2[3]*Tnb5[3])) + " / " + Tnb2[2] + " = " + Tnb5[2]) ;
						Console.WriteLine("{ z = " + Tnb4[4] + " / " + Tnb4[3] + " = " + Tnb5[3]) ;
					}
					else
					{
						Console.WriteLine("{ y = " + (Tnb3[4] - (Tnb3[3]*Tnb5[3])) + " / " + Tnb3[2] + " = " + Tnb5[2]) ;
						Console.WriteLine("{ z = " + Tnb2[4] + " / " + Tnb2[3] + " = " + Tnb5[3]) ;
					}

			// 9 - Encore des équations ?
					
					do{	
					Console.WriteLine(" ");
					Console.WriteLine("Encore des équations?(O/N)");
					texte=Console.ReadLine();
					texte=texte.ToUpper();
					}while(texte!="N" && texte!="O") ;
				
				}while(texte!="N") ;

    		}
	}
}

Conclusion

Mon prog trouve des arrondis au lieu de valeurs entières. Il faudrait convertir les flottants en entier.

Exemple avec le système d'équations de wikipédia :
+1x - 1y + 2z = +5
+3x + 2y + 1z = +10
+2x - 3y - 2z = -10

La réponse normale est :
x = 1
y = 2
z = 3

La réponse de mon prog :
x = 0,875
y = 2,125
z = 3,125

Es-ce que quelqu'un pourrait m'expliquer comment faire un arrondi en c#?
 

Commentaires et avis

signaler à un administrateur
Commentaire de kuise le 18/12/2005 20:13:29

Essayes avec Math.Round()

signaler à un administrateur
Commentaire de badrbadr le 19/12/2005 00:49:04

tu pourrais faire une classe fraction pour résoudre ton problème et pour maintenair ta precision maximale, je vais te passer la mienne:


public class CFraction
{
public int nominateur=0, denominateur=1;
public bool negative;

#region INITIALISATION DES VARIABLES
public CFraction(int x, int y)
{
//il est de la responsabilite de l utilisateur de cette classe de verifier
//si le denominateur est different de zero avant de l utiliser.
if(y==0) y=1; //pour eviter une erreur
if(Math.Sign((double)x/y)==-1)
negative = true;
else negative = false;
nominateur = Math.Abs(x);
denominateur = Math.Abs(y);
}
#endregion

#region OPERATEUR +
public static CFraction operator +(CFraction a, CFraction b)
{
CFraction fractionRetour;
if(b.negative == false) fractionRetour = CFraction.Addition(a, b);
else fractionRetour = CFraction.Soustraction(a, b);
fractionRetour = CFraction.Reduire(fractionRetour);
return fractionRetour;
}
#endregion
#region OPERATEUR -
public static CFraction operator -(CFraction a, CFraction b)
{
CFraction fractionRetour;
if(b.negative == false) fractionRetour = CFraction.Soustraction(a, b);
else fractionRetour = CFraction.Addition(a, b);
fractionRetour = CFraction.Reduire(fractionRetour);
return fractionRetour;
}
#endregion
#region MULTIPLICATION DE DEUX FRACTIONS
public static CFraction operator *(CFraction a, CFraction b)
{
int nom, denom;
bool negative;
if((a.negative && b.negative) || (!a.negative && !b.negative))
negative = false;
else
negative = true;
nom = a.nominateur * b.nominateur;
denom = a.denominateur * b.denominateur;
CFraction fractionRetour = new CFraction(nom, denom);
fractionRetour.negative = negative;
fractionRetour = CFraction.Reduire(fractionRetour);
return fractionRetour;
}
#endregion
#region DIVISION DE DEUX FRACTIONS
public static CFraction operator /(CFraction a, CFraction b)
{
int temp;
temp = b.nominateur;
b.nominateur = b.denominateur;
b.denominateur = temp;
return a*b;
}
#endregion
#region FONCTION QUI ADDITIONNE DEUX FRACTIONS
public static CFraction Addition(CFraction a, CFraction b)
{
int nom, denom;
if(a.negative == false)
nom = a.nominateur * b.denominateur + b.nominateur * a.denominateur;
else
nom = - a.nominateur * b.denominateur + b.nominateur * a.denominateur;
denom = a.denominateur * b.denominateur;
return new CFraction(nom, denom);
}
#endregion
#region FONCTION QUI SOUSTRAIT DEUX FRACTIONS
public static CFraction Soustraction(CFraction a, CFraction b)
{
int nom, denom;
if(a.negative == false)
nom = a.nominateur * b.denominateur - b.nominateur * a.denominateur;
else
nom = - a.nominateur * b.denominateur - b.nominateur * a.denominateur;
denom = a.denominateur * b.denominateur;
return new CFraction(nom, denom);
}
#endregion
#region FONCTION QUI REDUIT LES FRACTIONS
public static CFraction Reduire(CFraction fraction)
{
int nom = fraction.nominateur;
int denom = fraction.denominateur;
int reste;
do
{
Math.DivRem(nom, denom, out reste);
if(reste != 0)
{
nom = denom;
denom = reste;
}
}while(reste != 0);

CFraction fractionRetour = new CFraction(fraction.nominateur/denom, fraction.denominateur/denom);
fractionRetour.negative = fraction.negative;
return fractionRetour;
}
#endregion
}

signaler à un administrateur
Commentaire de badrbadr le 19/12/2005 00:53:20

ah oui, en d autres termes, au lieu que ca soit float le type de base dans ton programme, ca va etre CFraction

petite note: j'avais fait cette classe il y a de ca très longtemps, mais je me rappèle tout de même qu'elle fonctionnait nickel

voici un exemple d utilisation:
CFraction fraction1 = new CFraction(1, 2);
CFraction fraction2 = new CFraction(3, 4);
CFraction fraction3 = fraction1 + fraction2;
if(fraction3.negative==false) Console.WriteLine("{0}/{1}", fraction3.nominateur, fraction3.denominateur);
else Console.WriteLine("-{0}/{1}", fraction3.nominateur, fraction3.denominateur);

bon, je vais arreter de polluer les commentaires :D

signaler à un administrateur
Commentaire de jehan1 le 02/09/2006 19:59:09

Je suis quelque peu étonné de l'erreur énorme sur l'exemple :

La réponse normale est :
x = 1
y = 2
z = 3
La réponse du prog :
x = 0,875
y = 2,125
z = 3,125

Avant d'arrondir à posteriori, il me semble que pour la méthode de Gauss, il y a une façon de réduire les erreurs d'arrondi (pivot optimal de Gauss un truc comme ça).



Ajouter un commentaire



Nos sponsors

Sondage...

CalendriCode

Décembre 2008
LMMJVSD
1234567
891011121314
15161718192021
22232425262728
293031    

Consulter la suite du CalendriCode

Téléchargements

Logiciels à télécharger sur le même thème :



Développement réalisé par Nicolas SOREL (Nix) avec l'aide de : Cyril DURAND et Emmanuel BAÏSE, Merci à Vincent pour ses précieux conseils
CodeS-SourceS.com© Toute reproduction même partielle est interdite sauf accord écrit du Webmaster
CodeS-SourceS.com© est une marque déposée tous droits réservés
Temps d'éxécution de la page : 0,343 sec

Google Coop CodeS-SourceS Google Coop CodeS-SourceS


Certaines images présentes sur le site (notament certains avatars) sont issues des collections IconShock, donc si vous souhaitez utiliser ces icons vous devez les acheter, ne les copiez pas et ne utilisez pas dans vos sites et applications sans les avoir commandé.