Variable ganzrationale Funktionen n-ten Grades

guiller

Grünschnabel
Hallo Leute,

bin hier ganz neu, und bin ein C-Anfänger, ich denke mal dass es hier ein paar kompetente und nette Leute gibt, die sich mit C auskennen, also ich habe folgendes Problem, ich habe ein Programm geschrieben dass die Nullstellen einer Funktion ausrechnet, also nur Näherungswerte, jetzt kann man in meinem Programm nur Funktionen des 3.Grades benützten, da ich nicht weiß wie ich das anders machen soll, gibt es irgendeine Möglichkeit, dass man eingeben kann wie hoch der Grad sein soll, und dann die Funktion gebildet wird? Ich weiß nur dass man mit der Funktion pow(x,3) z.B. das x³ machen kann, aber ich weiß nicht wie ich das mit dem Grad n hinbekommen soll , kann man das irgendwie mit einer for-Schleife lösen, so z.B. oder ist das nicht möglich?
for (n=0;n<=4;n++) { Und hier irgendwie einen Code der dann immer
die Grade aneinanderhängt z.b. a x ^n und dann in der nächsten for Schleife b*x^n-1 oder sowas
}

Ich weiß nicht, jemanden den ich kenne hatte mal was von Speicher alokieren oder soetwas gesagt, ich weiß aber nicht mehr genau, ich hoffe ich habe mich verständlich ausgedrückt, und hier zuguterletzt mal mein Quellcode, damit ihr mal meinen kleinen Algorithmus seht:

Code:
#include <stdio.h>
#include <math.h>


//Koeffizienten
struct funktion {
	double a;
	double b;
	double c;
	double d;
} f1;

//Funktion selbst:
//----->

double f(double x) {
	
	
	return f1.a*x*x*x+f1.b*x*x+f1.c*x+f1.d;
}


//Nullstellenfunktion, findet raus, was linke und rechte Grenze ist, und übergibt dann den neuen Mittelwert.

double NS(double LG ,double RG)  {
	double MW=(LG+RG)/2;

		if(  round(  f(MW)*1000000 ) /1000000 == 0.0) return MW;

		if (f(LG) > 0.0 && f(RG) < 0.0) {		
		if( f(MW) > 0.0) return NS(MW,RG);
		if( f(MW) < 0.0) return NS(LG,MW);
	} 
	
		if (f(LG) < 0.0 && f(RG) > 0.0) {
			if( f(MW) > 0.0) return NS(LG,MW);
			if( f(MW) < 0.0) return NS(MW,RG);
	}

	return MW;
}
	
int main() {
int ia,ie;

	//Hier werden a,b,c und d ermittelt.
	printf("Algorithmus zum Ermitteln von Nullstellen einer Funktion (max. Grad3) zwischen zwei Grenzen");

	printf("\n\nFunktionsaufbau : ax^3 + bx^2  + cx + d !");
	printf("\na > ");
	scanf("%lf",&f1.a);
	printf("\nb > ");
	scanf("%lf",&f1.b);
	printf("\nc > ");
	scanf("%lf",&f1.c);
	printf("\nd > ");
	scanf("%lf",&f1.d);

	printf("Linke Grenze > ");
	scanf("%i",&ia);

	printf("Rechte Grenze > ");
	scanf("%i",&ie);

	printf("Nullstelle von f(x) zwischen %i und %i ist %.16lf\n", ia,ie,NS(ia,ie));

	printf("Ende.");
	
	return 0;
	
}
 
Statt pow(x, 3); kannst du natürlich auch pow(x, n); schreiben.

Du könntest das ganze mit einer Schleife lösen, wenn du alle Koeffizienten deiner Funktion zB in ein Array / Vector speicherst.
Der Benutzer müsste natürlich zuvor den Grad deines Polynoms eingeben.

Schreibst du reines C oder auch C++?
Würde dir empfehlen dich nicht auf C zu beschränken.


/EDIT:


Speicher allozieren:
Das bedeutet, du holst dir zur Runtime Speicher vom OS.
Sowas macht man gerne, wenn man zur Compiletime nicht weiß, wann oder ob eine Variable gebraucht wird, oder wie viele Variablen gebraucht werden.

D.h. Wenn du zur Compiletime nicht weißt, wie groß dein Polynom werden soll und du (theoretisch) unendlich große Polynome zulassen willst, dann kannst du nicht schon im Quellcode entscheiden, wie viele Koeffizienten du brauchst.
In dem Fall würdest du dir dynamisch (=zur Runtime) Speicher allozieren.

sieht so aus:

C++:
int* koeffizienten = new int[n+1];

Wobei das glaub in reinem C nicht funktioniert.. da musst du malloc(); benutzen.


Für deine Zwecke reicht es aber auch (wahrshceinlich) ein Array von vielleicht 20 ints anzulegen, da du sowieso nie eine GRF von einem solch hohen Grad behandeln wirst.. (oder doch?)
 
Zuletzt bearbeitet:
Hmm hab mir schon gedacht, irgendwie mit arrays, hab aber keine Ahnung wie , könntest du mir mal nen kurzen Codeschnipsel schreiben, das wäre nett

Ja, ich kann ein bisschen C++ , aber in C bin ich auch noch nicht so gut, also habe ich erst vor besser C zu lernen und dann richtig C++

Edit: Nein, für meine Zwecke reicht der Grad 20 völlig aus, aber wie soll ich denn das machen? ich hab zwar dann eine Variable bzw Array aber was mach ich damit :( Bin bei diesem Thema echt hilflos, wie kann ich eine Funktion bauen, für die der Benutzer dann selbstständig Koeffizienten bei den jeweiligen Graden angeben kann wie ich das schon bei meiner Funktion mit dem Grad 3 getan habe?
 
Zuletzt bearbeitet:
Ok.

C++:
double f_x(int f_grad, double f_koeff[], int x)  // rechnet wert f(x) an der stelle x aus
{
  double result = 0;
  for (int i = 0; i <= f_grad; ++i)
  {
    result += f_koeff[i] * pow(x, i);
  }
  return result;
}


int main()
{

  int n;
  double koeffizienten[21];
    // 'n' und 'koeffizienten' muessen durch benutzereingabe (oder sonstwie)
    // initialisiert werden

   // dann kannst du damit rechnen, zb den wert an der stelle i ausrechnen:
   int x0 = 12;

   printf("f(%i) = %i", x0, f_x(n, koeffizienten, x0);
}
 
Ok vielen dank, ich habe da jetzt ein bisschen rumprobiert, habs zwar noch nicht geschafft aber das kommt schon noch, nur noch eine Frage in f_x() wie trage ich da die Koeffizienten ein, angenommen ich habe den grad 3, also habe ich 4 koeffizienten , wie soll ich die in f_x eintragen?
 
Du initialisierst zunächst ein Array mit deinen Koeffis.
Und dann übergibst du das Array an deine Funktion f_x (oder auch an deine nullstellenfunktion, die dann wie f_x ein array und grad als Parameter bräuchte, um allgemein zu arbeiten)


C++:
  double koeffizienten[21];

  koeffizienten[0] = 0;
  koeffizienten[1] = 0;
  koeffizienten[2] = 3;
  koeffizienten[3] = 0;
  koeffizienten[4] = 2;        // f(x) = 2x^4 + 3 x^2


  double f_9 = f_x(                  // f(9)
                         4,                    // grad 4
                         koeffizienten,    // arbeite mit den hier definierten 'koeffizienten'
                         9.0);                 // stelle 9
 
Ah ok ich kann da einfach koeffizienten reinschreiben , ich brauche net irgendwie ne for schleife oder sowas reinmachen ? Das ist ja praktisch soso ;)

Edit:
Hier mal der Code, aber da kommen irgendwie immer falsche Werte raus wenn ich ne Gerade oder z.B. ne Parabel nehme
Code:
#include <stdio.h>
#include <stdlib.h>
#include <math.h>

double f (int Grad, double Koeffizienten[], int x)  // rechnet wert f(x) an der stelle x aus

{  
double Ergebnis = 0;  
for (int i = 0; i <= Grad; ++i)  
	{   
		Ergebnis += Koeffizienten[i] * pow(x, i);  
	}  

return Ergebnis;

}

int main() {	

	
	int x;
	int Grad;
	double Koeffizient[21];

	//Abfragen des Grades
	printf("Grad >");
	scanf("%i",&Grad);

	//Abfragen der Koeffizienten
	for (x=0;x<=Grad;x++) {
		printf("Koeffizient Nr %i >",x);
		scanf("%lf",&Koeffizient[x]);
	}

	
	int x0=1;

	printf("f(%i) = %i", x0, f(Grad, Koeffizient, x0));
	system("pause");
	return 0;
}
 
Zuletzt bearbeitet:
Oh..
Sorry, mein Fehler..

Die Funktion f_x gibt double zurück, das musst du dem printf natürlich auch sagen.

also nicht %i, sondern %f:

C++:
printf("f(%i) = %f", x0, f(Grad, Koeffizient, x0));

Wobei ich mir allerdings nicht sicher bin, ob %f einen double oder float impliziert...
Könnte also immernoch falsch sein.

Zudem ist es natürlich sinnvoll, die Funktion f_x so zu definieren, dass sie als Stelle nicht auf eine Ganzzahl beschränkt bleibt...
 
oh super, danke jetzt gehts du hast mir echt weitergeholfen , vielen dank ^^
ja genau also bei double muss man %lf schreiben für longfloat, wenigstens etwas das ich weiß ;)
 
Zurück