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

#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;
}