Polynom Addition

Dragonslayer

Also ich habe mir eine Klasse geschrieben, die Polynome Addieren soll und den grad des Polynoms wiedergeben soll.

wenn ich aber jetzt zb

y1=x^2+2
y2=-x^2-2

y1=y1+y2

mache müsste ja y1=0 gelten Also grad 0.

Ich gehe bei der Speicherung so vor das ich es in ein double array speichere und die array stellen für den grad des polynoms stehen.

class Polynom  
{
public:
	Polynom();                   
	Polynom(Polynom const&);     
	~Polynom();                  

	Polynom& operator=(Polynom const&);  
	Polynom& operator+=(Polynom const&); // gradcheck?

        void print ()const;       //Ausgabe Polynomarray       

	void set(int,double);          //einzelne Polystelle im array hinzufügen
	void check_grad();                
        int Grad();                        

private:
	int res,grad;
	double *a;         //Multiplikatorfeld zb   3*x^2    3=>a[2]

};

Polynom::Polynom()
{
	a=new double[20];  
	grad=0,res=20;

	for(int n=0; n<res; n++)   //Standardpolynom P=0
	{
		a[n]=0;
	}
}

Polynom::Polynom(Polynom const &p)    
{
	grad=p.grad;
	for(int n=0; n < grad; n++)
	{
		a[n]=p.a[n];
	}
}

Polynom::~Polynom()
{
	delete []a;
}

void Polynom::check_grad()
{
	for(int n=res-1; n>=0; n--)
	{
		if(a[n]!=0)
		{
			grad=n;
			break;
		}
	}
	if(n==0)  //wenn n bis auf 0 runterläuft muß gelten y=0, daher grad=0
	{
		grad=n;
	}
}

Polynom& Polynom::operator+=(Polynom const& a_polynom)
{

	for(int n=0; n<= grad; n++)
	{
		a[n]+=a_polynom.a[n];
	}
    check_grad();
	return *this;
}

wenn ich jetzt in der main folgendes mache:

int main()
{
	Polynom r,q;
	r.set(0,15);
	r.set(1,1);
	r.set(2,4);								
	q.set(0,-15);
	q.set(1,-1);
	q.set(2,-4);
	q+=r;
	cout<<"Polynom:";
	q.print();
	cout<<"Grad des Polynoms:"<<q.Grad()<<endl;
	return 0;
}

Die q.Grad müsste jetzt eigentlich den Grad 0 liefern stattdessen bekomme ich Grad 2. Ich vermute die check Methode hat nicht q sondern bei r den Grad gecheckt. Aber wie läßt sich das beheben?

zero_gravity

Auf die schnelle sehe ich da keinen Fehler im Code. Hast du vielleicht vergessen, in der set methode den grad zu verändern? sonst wird im += operator ja immer nur der x^0 term addiert, weil grad noch auf 0 steht.

Hazzel

Du musst im += das Array schon ganz durchgehen, sonst hast du ein Problem wenn der 2. Operand einen höheren Grad hat.

Dragonslayer

also ich hab mir das so gedacht ich gehe von Hinten durch bis ich nen array finde was nicht gleich 0 ist, das muß dann ja eigentlich der höchste grad sein`?

Ich hab das gefühl die check funktion in += testet in dem fall das falsche array

Hazzel schrieb:

Du musst im += das Array schon ganz durchgehen, sonst hast du ein Problem wenn der 2. Operand einen höheren Grad hat.

hast recht das hab ich in der tat nicht bedacht.

edit:

Also ich hab die methode jetzt so geändert:

Polynom& Polynom::operator+=(Polynom const& a_polynom)
{

	for(int n=0; n< res; n++)
	{
		a[n]+=a_polynom.a[n];
	}
    check_grad();
	return *this;
}

trotzdem kommt bei q+=r Grad 2 raus obwohl der eigentlich 0 sein müßte
q=-4x^2-x-15 r=4x^2+x+15
müsste ja eigentlich q=0 ergeben daher grad 0.
ich vermute das die check_grad() das array von r checkt was ja nen Grad von 2 hat.
Nur wie läßt es sich beheben?

edit:
hat sich erledigt ich habe check_grad abgeändert jetzt gehts

void Polynom::check_grad()
{
	for(int n=res-1; n>=0; n--)
	{
		if(a[n]!=0)
		{
			grad=n;
			break;
		}
		if(n==0)  //wenn n bis auf 0 runterläuft muß gelten y=0, daher grad=0
		{
			grad=n;
		}
	}

}