begin process at 2012 02 09 07:57:06
  Trouver un code source :
 
dans
 
Accueil > 

Code

 > 

Maths & Algorithmes

 > RESOLUTION D'EQUATIONS (JUSQU'AU 3EME DEGRE) + CLASSE POUR MANIPULER LES NOMBRES COMPLEXES [DJGPP]

RESOLUTION D'EQUATIONS (JUSQU'AU 3EME DEGRE) + CLASSE POUR MANIPULER LES NOMBRES COMPLEXES [DJGPP]


 Information sur la source

Note :
8,5 / 10 - par 4 personnes
8,50 / 10

  • 1

  • 2

  • 3

  • 4

  • 5

  • 6

  • 7

  • 8

  • 9

  • 10
Catégorie :Maths & Algorithmes Niveau :Initié Date de création :07/04/2005 Date de mise à jour :07/04/2005 23:22:06 Vu / téléchargé :10 643 / 360

Auteur : gorgonzola

Ecrire un message privé
Site perso
Commentaire sur cette source (5)
Ajouter un commentaire et/ou une note

 Description

Cliquez pour voir la capture en taille normale
Voici un petit programme qui résout les équations du premier, deuxième et troisième degré. Une classe pour manier les complexes avec surcharge des opérateurs est également implémentée pour simplifier la résolution des équations du troisième degré.
Je sais bien qu'il y a déjà une classe pour manipuler les complexes en C++, mais je n'aime pas le travail tout fait alors j'en ai refait une.

Source

  • #include <conio.h>
  • #include <math.h>
  • #include <stdio.h>
  • #include <stdlib.h>
  • ////////////////////////////////////////////////////////////////////////////////////////////////////
  • class ZM_comp
  • {
  • private:
  • double x;
  • double y;
  • friend ZM_comp operator+(const ZM_comp &c);
  • friend ZM_comp operator-(const ZM_comp &c);
  • friend ZM_comp operator+(const ZM_comp &c1,const ZM_comp &c2);
  • friend ZM_comp operator-(const ZM_comp &c1,const ZM_comp &c2);
  • friend ZM_comp operator*(const ZM_comp &c1,const ZM_comp &c2);
  • friend ZM_comp operator/(const ZM_comp &c1,const ZM_comp &c2);
  • public:
  • ZM_comp(const ZM_comp &c);
  • ZM_comp(double a=0,double b=0);
  • double Re();
  • double Im();
  • double Mod();
  • double Arg();
  • void Coord(double a,double b);
  • void Polar(double mod,double arg);
  • ZM_comp Conj();
  • ZM_comp Root(unsigned n,unsigned k);
  • bool operator==(const ZM_comp &c);
  • bool operator!=(const ZM_comp &c);
  • bool operator<=(const ZM_comp &c);
  • bool operator>=(const ZM_comp &c);
  • bool operator<(const ZM_comp &c);
  • bool operator>(const ZM_comp &c);
  • ZM_comp &operator=(const ZM_comp &c);
  • ZM_comp &operator+=(const ZM_comp &c);
  • ZM_comp &operator-=(const ZM_comp &c);
  • ZM_comp &operator*=(const ZM_comp &c);
  • ZM_comp &operator/=(const ZM_comp &c);
  • };
  • ////////////////////////////////////////////////////////////////////////////////////////////////////
  • ZM_comp::ZM_comp(const ZM_comp &c)
  • {
  • x=c.x;
  • y=c.y;
  • }
  • ZM_comp::ZM_comp(double a,double b)
  • {
  • x=a;
  • y=b;
  • }
  • double ZM_comp::Re()
  • {
  • return x;
  • }
  • double ZM_comp::Im()
  • {
  • return y;
  • }
  • double ZM_comp::Mod()
  • {
  • return hypot(x,y);
  • }
  • double ZM_comp::Arg()
  • {
  • double arg;
  • double mod;
  • mod=hypot(x,y);
  • if (mod==0.) return 0.;
  • arg=acos(x/mod);
  • if (y<0.) arg=2*PI-arg;
  • return arg;
  • }
  • void ZM_comp::Coord(double a,double b)
  • {
  • x=a;
  • y=b;
  • }
  • void ZM_comp::Polar(double mod,double arg)
  • {
  • x=mod*cos(arg);
  • y=mod*sin(arg);
  • }
  • ZM_comp ZM_comp::Conj()
  • {
  • ZM_comp c(x,-y);
  • return c;
  • }
  • ZM_comp ZM_comp::Root(unsigned n,unsigned k)
  • {
  • ZM_comp c;
  • c.Polar(pow(Mod(),1./(double)(n)),(Arg()+2.*(double)(k)*PI)/(double)(n));
  • return c;
  • }
  • bool ZM_comp::operator==(const ZM_comp &c)
  • {
  • return (x==c.x)&&(y==c.y);
  • }
  • bool ZM_comp::operator!=(const ZM_comp &c)
  • {
  • return (x!=c.x)||(y!=c.y);
  • }
  • bool ZM_comp::operator<=(const ZM_comp &c)
  • {
  • return (x<=c.x);
  • }
  • bool ZM_comp::operator>=(const ZM_comp &c)
  • {
  • return (x>=c.x);
  • }
  • bool ZM_comp::operator<(const ZM_comp &c)
  • {
  • return (x<c.x);
  • }
  • bool ZM_comp::operator>(const ZM_comp &c)
  • {
  • return (x>c.x);
  • }
  • ZM_comp &ZM_comp::operator=(const ZM_comp &c)
  • {
  • if (&c!=this)
  • {
  • x=c.x;
  • y=c.y;
  • }
  • return *this;
  • }
  • ZM_comp &ZM_comp::operator+=(const ZM_comp &c)
  • {
  • x+=c.x;
  • y+=c.y;
  • return *this;
  • }
  • ZM_comp &ZM_comp::operator-=(const ZM_comp &c)
  • {
  • x-=c.x;
  • y-=c.y;
  • return *this;
  • }
  • ZM_comp &ZM_comp::operator*=(const ZM_comp &c)
  • {
  • double temp=x*c.y+c.x*y;
  • x=x*c.x-y*c.y;
  • y=temp;
  • return *this;
  • }
  • ZM_comp &ZM_comp::operator/=(const ZM_comp &c)
  • {
  • double mod=c.x*c.x+c.y*c.y;
  • double temp=(c.x*y-x*c.y)/mod;
  • x=(x*c.x+y*c.y)/mod;
  • y=temp;
  • return *this;
  • }
  • ZM_comp operator+(const ZM_comp &c1,const ZM_comp &c2)
  • {
  • ZM_comp ret=c1;
  • return ret+=c2;
  • }
  • ZM_comp operator-(const ZM_comp &c1,const ZM_comp &c2)
  • {
  • ZM_comp ret=c1;
  • return ret-=c2;
  • }
  • ZM_comp operator-(const ZM_comp &c)
  • {
  • return 0-c;
  • }
  • ZM_comp operator+(const ZM_comp &c)
  • {
  • return 0+c;
  • }
  • ZM_comp operator*(const ZM_comp &c1,const ZM_comp &c2)
  • {
  • ZM_comp ret=c1;
  • return ret*=c2;
  • }
  • ZM_comp operator/(const ZM_comp &c1,const ZM_comp &c2)
  • {
  • ZM_comp ret=c1;
  • return ret/=c2;
  • }
  • ////////////////////////////////////////////////////////////////////////////////////////////////////
  • #define PRECISION 10000
  • int resoudre2(ZM_comp a,ZM_comp b,ZM_comp c,ZM_comp* x);
  • int resoudre3(ZM_comp a,ZM_comp b,ZM_comp c,ZM_comp d,ZM_comp* x);
  • int resoudre4(ZM_comp a,ZM_comp b,ZM_comp c,ZM_comp d,ZM_comp e,ZM_comp* x);
  • int main(int argc,char** argv)
  • {
  • int deg;
  • int i;
  • double coef[4];
  • ZM_comp sol[4];
  • // affichage du titre
  • printf("RESOLUTION D'EQUATIONS\r\n"
  • "ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ\r\n");
  • // recolte les coefficients de l'equation s'ils
  • // sont passes au programme par ligne de commande
  • if (argc>1)
  • {
  • for (deg=0 ; (deg+1<argc)&&(deg<4) ; deg++) sscanf(argv[deg+1],"%lf",coef+deg);
  • printf("\r\n");
  • }
  • // sinon, l'utilisateur entre les coefficients
  • else
  • {
  • printf("\r\n");
  • for (i=0 ; i<4 ; i++)
  • {
  • printf("degr&#8218; %d : ",i);
  • scanf("%lf",coef+i);
  • if (coef[i]!=0.) deg=i;
  • }
  • printf("\r\n");
  • }
  • // si l'utilisateur n'a pas rentre assez de coefficients
  • if (deg==0)
  • {
  • printf("il ne s'agit pas d'une &#8218;quation");
  • while (getch()!='\r');
  • return 0;
  • }
  • // affiche l'equation a resoudre
  • for (i=0 ; i<=deg ; i++)
  • {
  • // si le coefficient est nul, autant ne rien noter
  • if (coef[deg-i]==0.) continue;
  • // si le coefficient est un, autant afficher juste le signe
  • if ((fabs(coef[deg-i])==1.)&&(deg-i!=0)) printf("%+1.0f\b",coef[deg-i]);
  • // affiche le coefficient, avec une
  • // ou zero decimale selon le besoin
  • else printf("%+.*f",(int)ceil(coef[deg-i]-floor(coef[deg-i])),coef[deg-i]);
  • // affiche l'exposant
  • if (deg-i==1) printf("x");
  • else if (deg-i==2) printf("");
  • else if (deg-i==3) printf("");
  • }
  • printf(" = 0");
  • if (coef[deg]>0.) printf("\r ");
  • // resolution des equations, a partir d'ici la
  • // variable deg contient le nombre de solutions
  • printf("\r\n\r\nLes solutions r&#8218;elles et/ou complexes sont :\r\n\r\n");
  • if (deg==1) sol[0]=-coef[0]/coef[1];
  • else if (deg==2) deg=resoudre2(coef[2],coef[1],coef[0],sol);
  • else if (deg==3) deg=resoudre3(coef[3],coef[2],coef[1],coef[0],sol);
  • // affichage des solutions
  • for (i=0 ; i<deg ; i++)
  • {
  • printf("\t%.8f",sol[i].Re());
  • if (sol[i].Im()!=0) printf(" + %.8fi",sol[i].Im());
  • printf("\r\n");
  • }
  • // attend que enter soit presse puis quitte
  • while (getch()!='\r');
  • return 0;
  • }
  • int resoudre2(ZM_comp a,ZM_comp b,ZM_comp c,ZM_comp* x)
  • {
  • int n;
  • ZM_comp delta;
  • delta=b*b-4*a*c;
  • if (delta==0.) n=1;
  • else n=2;
  • x[0]=(-b+delta.Root(2,0))/(2*a);
  • x[1]=(-b-delta.Root(2,0))/(2*a);
  • return n;
  • }
  • int resoudre3(ZM_comp a,ZM_comp b,ZM_comp c,ZM_comp d,ZM_comp* x)
  • {
  • int n;
  • int i;
  • int i2;
  • int p3;
  • ZM_comp p;
  • ZM_comp q;
  • ZM_comp z[2][3];
  • p=(3*a*c-b*b)/(3*a*a);
  • q=(2*b*b*b-9*a*b*c+27*a*a*d)/(27*a*a*a);
  • resoudre2(1,q,-(p*p*p)/27,x);
  • for (i=0 ; i<3 ; i++) z[0][i]=x[0].Root(3,i);
  • for (i=0 ; i<3 ; i++) z[1][i]=x[1].Root(3,i);
  • n=0;
  • p3=(int)((-p.Re()/3)*PRECISION);
  • for (i=0 ; i<3 ; i++)
  • {
  • for (i2=0 ; i2<3 ; i2++)
  • {
  • if ((int)((z[0][i]*z[1][i2]).Re()*PRECISION)==p3)
  • {
  • x[n]=z[0][i]+z[1][i2]-b/(3*a);
  • x[n].Coord
  • (
  • x[n].Re(),
  • ((double)(int)(x[n].Im()*PRECISION))/PRECISION
  • );
  • if (n==0) n=1;
  • else if (n==1)
  • {
  • if (x[1]!=x[0]) n=2;
  • }
  • else if (n==2)
  • {
  • if ((x[2]!=x[0])&&(x[2]!=x[1])) n=3;
  • }
  • }
  • }
  • }
  • return n;
  • }
#include	<conio.h>
#include	<math.h>
#include	<stdio.h>
#include	<stdlib.h>

////////////////////////////////////////////////////////////////////////////////////////////////////

class		ZM_comp
{
		private:

	double	x;
	double	y;

	friend ZM_comp	operator+(const ZM_comp &c);
	friend ZM_comp	operator-(const ZM_comp &c);
	friend ZM_comp	operator+(const ZM_comp &c1,const ZM_comp &c2);
	friend ZM_comp	operator-(const ZM_comp &c1,const ZM_comp &c2);
	friend ZM_comp	operator*(const ZM_comp &c1,const ZM_comp &c2);
	friend ZM_comp	operator/(const ZM_comp &c1,const ZM_comp &c2);

		public:

		ZM_comp(const ZM_comp &c);
		ZM_comp(double a=0,double b=0);

	double	Re();
	double	Im();
	double	Mod();
	double	Arg();
	void	Coord(double a,double b);
	void	Polar(double mod,double arg);
	ZM_comp	Conj();
	ZM_comp	Root(unsigned n,unsigned k);

	bool	operator==(const ZM_comp &c);
	bool	operator!=(const ZM_comp &c);
	bool	operator<=(const ZM_comp &c);
	bool	operator>=(const ZM_comp &c);
	bool	operator<(const ZM_comp &c);
	bool	operator>(const ZM_comp &c);
	ZM_comp	&operator=(const ZM_comp &c);
	ZM_comp	&operator+=(const ZM_comp &c);
	ZM_comp	&operator-=(const ZM_comp &c);
	ZM_comp	&operator*=(const ZM_comp &c);
	ZM_comp	&operator/=(const ZM_comp &c);
};

////////////////////////////////////////////////////////////////////////////////////////////////////

	ZM_comp::ZM_comp(const ZM_comp &c)
{
	x=c.x;
	y=c.y;
}

	ZM_comp::ZM_comp(double a,double b)
{
	x=a;
	y=b;
}

double	ZM_comp::Re()
{
	return x;
}

double	ZM_comp::Im()
{
	return y;
}

double	ZM_comp::Mod()
{
	return hypot(x,y);
}

double	ZM_comp::Arg()
{
	double	arg;
	double	mod;

	mod=hypot(x,y);
	if (mod==0.) return 0.;
	arg=acos(x/mod);
	if (y<0.) arg=2*PI-arg;
	return arg;
}

void	ZM_comp::Coord(double a,double b)
{
	x=a;
	y=b;
}

void	ZM_comp::Polar(double mod,double arg)
{
	x=mod*cos(arg);
	y=mod*sin(arg);
}

ZM_comp	ZM_comp::Conj()
{
	ZM_comp	c(x,-y);
	return c;
}

ZM_comp	ZM_comp::Root(unsigned n,unsigned k)
{
	ZM_comp	c;

	c.Polar(pow(Mod(),1./(double)(n)),(Arg()+2.*(double)(k)*PI)/(double)(n));
	return c;
}

bool	ZM_comp::operator==(const ZM_comp &c)
{
	return (x==c.x)&&(y==c.y);
}

bool	ZM_comp::operator!=(const ZM_comp &c)
{
	return (x!=c.x)||(y!=c.y);
}

bool	ZM_comp::operator<=(const ZM_comp &c)
{
	return (x<=c.x);
}

bool	ZM_comp::operator>=(const ZM_comp &c)
{
	return (x>=c.x);
}

bool	ZM_comp::operator<(const ZM_comp &c)
{
	return (x<c.x);
}

bool	ZM_comp::operator>(const ZM_comp &c)
{
	return (x>c.x);
}

ZM_comp	&ZM_comp::operator=(const ZM_comp &c)
{
	if (&c!=this)
	{
		x=c.x;
		y=c.y;
	}
	return *this;
}

ZM_comp	&ZM_comp::operator+=(const ZM_comp &c)
{
	x+=c.x;
	y+=c.y;
	return *this;
}

ZM_comp	&ZM_comp::operator-=(const ZM_comp &c)
{
	x-=c.x;
	y-=c.y;
	return *this;
}

ZM_comp	&ZM_comp::operator*=(const ZM_comp &c)
{
	double	temp=x*c.y+c.x*y;

	x=x*c.x-y*c.y;
	y=temp;
	return *this;
}

ZM_comp	&ZM_comp::operator/=(const ZM_comp &c)
{
	double	mod=c.x*c.x+c.y*c.y;
	double	temp=(c.x*y-x*c.y)/mod;

	x=(x*c.x+y*c.y)/mod;
	y=temp;
	return *this;
}

ZM_comp	operator+(const ZM_comp &c1,const ZM_comp &c2)
{
	ZM_comp	ret=c1;
	return ret+=c2;
}

ZM_comp	operator-(const ZM_comp &c1,const ZM_comp &c2)
{
	ZM_comp	ret=c1;
	return ret-=c2;
}

ZM_comp	operator-(const ZM_comp &c)
{
	return 0-c;
}


ZM_comp	operator+(const ZM_comp &c)
{
	return 0+c;
}

ZM_comp	operator*(const ZM_comp &c1,const ZM_comp &c2)
{
	ZM_comp	ret=c1;
	return ret*=c2;
}

ZM_comp	operator/(const ZM_comp &c1,const ZM_comp &c2)
{
	ZM_comp	ret=c1;
	return ret/=c2;
}

////////////////////////////////////////////////////////////////////////////////////////////////////

#define	PRECISION	10000

int	resoudre2(ZM_comp a,ZM_comp b,ZM_comp c,ZM_comp* x);
int	resoudre3(ZM_comp a,ZM_comp b,ZM_comp c,ZM_comp d,ZM_comp* x);
int	resoudre4(ZM_comp a,ZM_comp b,ZM_comp c,ZM_comp d,ZM_comp e,ZM_comp* x);

int	main(int argc,char** argv)
{
	int	deg;
	int	i;
	double	coef[4];
	ZM_comp	sol[4];

		// affichage du titre
	printf("RESOLUTION D'EQUATIONS\r\n"
               "ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ\r\n");

		// recolte les coefficients de l'equation s'ils
		// sont passes au programme par ligne de commande
	if (argc>1)
	{
		for (deg=0 ; (deg+1<argc)&&(deg<4) ; deg++) sscanf(argv[deg+1],"%lf",coef+deg);
		printf("\r\n");
	}

		// sinon, l'utilisateur entre les coefficients
	else
	{
		printf("\r\n");
		for (i=0 ; i<4 ; i++)
		{
			printf("degr&#8218; %d : ",i);
			scanf("%lf",coef+i);
			if (coef[i]!=0.) deg=i;
		}
		printf("\r\n");
	}

		// si l'utilisateur n'a pas rentre assez de coefficients
	if (deg==0)
	{
		printf("il ne s'agit pas d'une &#8218;quation");
		while (getch()!='\r');
		return 0;
	}

		// affiche l'equation a resoudre
	for (i=0 ; i<=deg ; i++)
	{
			// si le coefficient est nul, autant ne rien noter
		if (coef[deg-i]==0.) continue;


			// si le coefficient est un, autant afficher juste le signe
		if ((fabs(coef[deg-i])==1.)&&(deg-i!=0)) printf("%+1.0f\b",coef[deg-i]);

			// affiche le coefficient, avec une
			// ou zero  decimale selon le besoin
		else printf("%+.*f",(int)ceil(coef[deg-i]-floor(coef[deg-i])),coef[deg-i]);

			// affiche l'exposant
		if (deg-i==1) printf("x");
		else if (deg-i==2) printf("xý");
		else if (deg-i==3) printf("xü");
	}
	printf(" = 0");
	if (coef[deg]>0.) printf("\r ");

		// resolution des equations, a partir d'ici la
		// variable deg contient le nombre de solutions
	printf("\r\n\r\nLes solutions r&#8218;elles et/ou complexes sont :\r\n\r\n");
	if (deg==1) sol[0]=-coef[0]/coef[1];
	else if (deg==2) deg=resoudre2(coef[2],coef[1],coef[0],sol);
	else if (deg==3) deg=resoudre3(coef[3],coef[2],coef[1],coef[0],sol);

		// affichage des solutions
	for (i=0 ; i<deg ; i++)
	{
		printf("\t%.8f",sol[i].Re());
		if (sol[i].Im()!=0) printf(" + %.8fi",sol[i].Im());
		printf("\r\n");
	}

		// attend que enter soit presse puis quitte
	while (getch()!='\r');

	return 0;
}

int	resoudre2(ZM_comp a,ZM_comp b,ZM_comp c,ZM_comp* x)
{
	int	n;
	ZM_comp	delta;

	delta=b*b-4*a*c;

	if (delta==0.) n=1;
	else n=2;

	x[0]=(-b+delta.Root(2,0))/(2*a);
	x[1]=(-b-delta.Root(2,0))/(2*a);

	return n;
}

int	resoudre3(ZM_comp a,ZM_comp b,ZM_comp c,ZM_comp d,ZM_comp* x)
{
	int	n;
	int	i;
	int	i2;
	int	p3;
	ZM_comp	p;
	ZM_comp	q;
	ZM_comp	z[2][3];

	p=(3*a*c-b*b)/(3*a*a);
	q=(2*b*b*b-9*a*b*c+27*a*a*d)/(27*a*a*a);

	resoudre2(1,q,-(p*p*p)/27,x);

	for (i=0 ; i<3 ; i++) z[0][i]=x[0].Root(3,i);
	for (i=0 ; i<3 ; i++) z[1][i]=x[1].Root(3,i);

	n=0;
	p3=(int)((-p.Re()/3)*PRECISION);
	for (i=0 ; i<3 ; i++)
	{
		for (i2=0 ; i2<3 ; i2++)
		{
			if ((int)((z[0][i]*z[1][i2]).Re()*PRECISION)==p3)
			{
				x[n]=z[0][i]+z[1][i2]-b/(3*a);
				x[n].Coord
				(
					x[n].Re(),
					((double)(int)(x[n].Im()*PRECISION))/PRECISION
				);

				if (n==0) n=1;
				else if (n==1)
				{
					if (x[1]!=x[0]) n=2;
				}
				else if (n==2)
				{
					if ((x[2]!=x[0])&&(x[2]!=x[1])) n=3;
				}
			}
		}
	}

	return n;
}

 Conclusion

si vous ne savez pas comment résoudre une équation du 3ème degré, cherchez des informations sur la méthode de cardan sur Google, ce n'est pas si compliqué que ça (mais ça nécessite une connaissance de base des nombres complexes)

 Fichier Zip

Les Membres Club peuvent télécharger directement un fichier contenu dans le zip sans télécharger le zip en entier !

Télécharger le zip


 Historique

07 avril 2005 23:22:06 :

 Sources du même auteur

Source avec Zip DESSINER A LA MAIN UNE STRUCTURE FRACTALE [DJGPP] [VGA 13H]
Source avec Zip JEU DE LA VIE EN MODE VGA 11H [DJGPP]
Source avec Zip Source avec une capture GENERATEUR DE FRACTAL PERSONNALISE [VESA] [DJGPP]
Source avec Zip MODE VESA HAUTE RESOLUTION [DJGPP]
Source avec Zip Source avec une capture CUBE 3D EN ROTATION / MODE GRAPHIQUE VGA 13H / DJGPP

 Sources de la même categorie

Source avec Zip UN EXAMPLE D'APPLICATION EN CUDA DE L'ALGORITHME DE SCAN POU... par oguzaras
Source avec Zip Source avec une capture CHIFFREMENT DE VIGENERE par lajouad
Source avec Zip Source avec une capture ANALYSE SYNTAXIQUE par lajouad
Source avec Zip Source avec une capture STRUCTURE D'UNE MATRICE PAR LES LISTE LINÉAIRE (NON CONTUGUS... par benzarabel
Source avec Zip Source avec une capture DESSINER UNE ARBRE BINAIRE( MODE CONSOLE): par benzarabel

Commentaires et avis

Commentaire de aurel_azerty le 08/04/2005 13:47:40

putain c'est trop bien!!
aurel-azerty

Commentaire de algori le 09/04/2005 18:52:48

Effectivement, ton code marche bien avec en plus la gestion des complexes. Bravo ! Bon travail ! 9/10
@++

Commentaire de wiaeke le 09/04/2005 19:25:10

avec quel compilo tu as compiler ce prog a++
sinon pas mal

Commentaire de jad_raad le 16/05/2005 18:48:19

c'est bien je t felicite
bon travail

Commentaire de youness2002 le 18/10/2006 22:30:08

super script qui marche !!!!!!!!!!

 Ajouter un commentaire




Nos sponsors


Sondage...

Comparez les prix

CalendriCode

Février 2012
LMMJVSD
  12345
6789101112
13141516171819
20212223242526
272829    

Consulter la suite du CalendriCode

 
Développement réalisé par Nicolas SOREL (Nix) avec l'aide de : Cyril DURAND et Emmanuel (EBArtSoft), 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

Google Coop CodeS-SourceS Google Coop CodeS-SourceS
Temps d'éxécution de la page : 1,279 sec (4)

Nous contacter | Annoncer sur CodeS-SourceS | Mentions légales