Bitte mal Programmcode anschaun

[New C´ler]

hey...hab hier was geschrieben, wollte ma fragn, ob sich das vlt ma jmd anschaun würde und verbesserungstipps abgegeben will?
das berechnet polynome in einem intervall von obere grenze bis untere grenze....

#include <stdio.h>
#include <math.h>
#include <string.h>

int main(){

int i=0,len=0,g,h,z;
char x[100],a=97;
float s,o,u,v=0,n,k;

printf ("! Nullstellenberechnung eines Polynoms \n");
printf ("\n? Bitte Grad des Polynoms eingeben: ");
scanf("%d",&g);
h=g;
z=h;

printf("\n  f(x)=");

for(;g>=0;g--){    /*gibt funktion aus f(x)=ax^2+bx^1+cx^0+    das plus am ende nervt :)?? */
  printf("%cx^%d+",a,g);
  a++;
  }

printf ("\n\n? Bitte Koeffizienten eingeben: \n");
g=h; /*g wird wieder auf Ausganswertzurückgesetzt*/
a=97;/*a wird wieder auf Ausganswertzurückgesetzt*/

for(i=0;g>=0;g--){
  printf("\n %c=",a);
  scanf("%");             /*ohne das funktioniert die eingabe nicht richtig =/ */
  scanf("%d",&x[i]);
  i++;
  a++;
  }

i=0;/*i wird wieder auf ausganswert zurückgesetzt*/
printf("\n? Bitte untere Grenze eingeben: ");
scanf("%f",&u);
printf("\n? Bitte obere Grenze eingeben: ");
scanf("%f",&o);
printf("\n? Bitte Schrittweite eingeben: ");
scanf("%f",&s);

for(;u<=o;u+=s){/*u mit schrittweite*/

  while(i<=z){  /* u ohne schrittweite, erster durchlauf*/
    k=x[i];
    n=k*(pow(u,h));
    h--;
    i++;
    v+=n;
} 
printf("\nf(%.1f)=%.1f",u,v);
i=0;      /*i wieder zurücksetzen*/
h+=(z+1); /*h wieder zurücksetzen, +1, weil h durch h-- in der Schleife auf -1 gesetzt wurde*/
v=0;      /*v wieder zurücksetzen*/
}

scanf("%");
return 0;
}

 

[Arnd]

Folgende Kommentare:

- Variablen initialisieren
- Code einrücken
- Als Variablennamen nicht die Buchstaben des Alphabets benutzen.
Der Code wird wesentlich besser lesbar, wenn die Variablen Namen entsprechend ihrer Bedeutung haben.
Was machst Du wenn das Alphabet zu Ende ist :-)?
- Das scanf am Schluss, hat das eine Bedeutung?
- Statt float würde ich double verwenden, damit habe ich bessere Erfahrungen.

- Zweimal den Wert 97 hart im Code verwenden ist nicht so glücklich. Ein #define INIT_WERT 97 hilft da weiter.
Ein bisschen Fehlerbehandlung wäre auch nicht schlecht. Besser wäre wohl auch #define INIT_WERT 'a'
Was passiert wenn man z.B. als Grad Zahlen über 'z' eingibt? Sicher nichts vernünftiges.

Als positiv empfinde ich das öfter mal Kommentare auftauchen. Das das scanf nicht korrekt funktioniert, liegt wahrscheinlich daran das scanf bei %d einen int* als Eingabe erwartet. Das x Array aber vom Typ char ist.

D.h.

#define INIT_WERT 'a'

int x[100];
...
scanf( "%d", &x[i]);

MfG

Arnd

 

[New C´ler]

jahh, das scanf brauch ich für meinen compiler...sonst beendet er das programm un ich seh das endergebnis nicht. (die letzte printf anweisung)

ich benutze DEV-C++ hat jmd vlt noch ne nettes codeprogramm, was mir gleich beim schreiben des programms eben farbigen code anzeigt??

jahh, das ma nen guter tipp!
werd ich beherzign

hat jmd ne idee, wie ich das machn kann, damit am anfang die fukntion in der form

f(x)=ax^2+bx^1+cx^0 angegeben wird, ohne das ich nach der letzten 0 da noch nen + hab, sieht irgendwie doof aus

edit:

jahh, ich depp, warum bin ich nich auf define gekommn *doing*...nochmals danke

un japp, int x[100] funzt auch ohne zweites scanf...hät ich auch ma checkn müssn *hrr*

 

[Revontulet]

for(;g>=0;g--)
{    
   /*gibt funktion aus f(x)=ax^2+bx^1+cx^0+    das plus am ende nervt :)?? */  
   if(g>0)
      printf("%cx^%d+",a,g);
   else
      printf("%c",a);
   a++;
}

 

[riod]

Microsoft Visual Studio

 

[Revontulet]

Hab da mal eben was gebastelt.

#include "math.h"
#include "stdlib.h"
#include "stdio.h"

float funktionswert(int *, float *, float);

int main(int argc, char* argv[])
{
	int grad, i;
	float *koeffizienten, untere_grenze, obere_grenze, schrittweite, ergebnis, a, a_new;

	printf("Grad des Polynoms\n");
	do
	{
		scanf("%d",&grad);
	}	while(grad < 1);

	printf("Untere Grenze\n");
	scanf("%f",&untere_grenze);

	printf("Obere Grenze\n");
	do
	{
		scanf("%f",&obere_grenze);
	}	while(obere_grenze <= untere_grenze);

	printf("Schrittweite\n");
	do
	{
		scanf("%f",&schrittweite);
	}	while(schrittweite <= 0);

	/* Reservierung Speicherplatz für Koeffizienten und Einlesen der selbigen */
	koeffizienten = new float[grad+1];

	for(i=0; i<=grad; i++)
	{
		printf("\nFaktor vor x^%d :",i);
		scanf("%f",&koeffizienten[i]);
	}

	/* Ausgabe der Funktion */
	printf("f(x)=");
	for(i=grad; i>=0; i--)
	{
		if(i==grad)
			printf("%f*x^%d",koeffizienten[i],i);
		else if(i>1)
		{
			if(koeffizienten[i]>0)
				printf("+%f*x^%d",koeffizienten[i],i);
			else if(koeffizienten[i]<0)
				printf("%f*x^%d",koeffizienten[i],i);
		}
		else if(i==1)
		{
			if(koeffizienten[i]>0)
				printf("+%f*x",koeffizienten[i]);
			else if(koeffizienten[i]<0)
				printf("%f*x",koeffizienten[i]);
		}
		else
		{
			if(koeffizienten[i]>0)
				printf("+%f",koeffizienten[i]);
			else if(koeffizienten[i]<0)
				printf("%f",koeffizienten[i]);
		}
	}

	a = untere_grenze;

	/* Berechnung der Nullstellen */
	do
	{
		ergebnis = 0;

		/* Prüft, ob die Funktion in dem Intervall [untere_grenze - schrittweite, untere_grenze] ihr Vorzeichen wechselt */
		if(funktionswert(&grad,koeffizienten,(a - schrittweite)) * funktionswert(&grad,koeffizienten,a) < 0)
		{
			do
			{
				/*	Berechnung der genauen Nullstelle mittels Newton-Raphson:
								a_new = a - f(a)/f'(a)
					Näherung der Ableitung durch Differenzenquotient:
							f'(a) ~ [f(a+h)-f(a)]/h mit h = 1e-6
					=>	a_new = a - 1e-6 * f(a)/[f(a+1e-6)-f(a)]
				*/
				a_new		= a - (1e-6) * funktionswert(&grad,koeffizienten,a)/(funktionswert(&grad,koeffizienten,(a + 1e-6))-funktionswert(&grad,koeffizienten,a));
				ergebnis	= funktionswert(&grad,koeffizienten,a_new);
				a			= a_new;
			} while(ergebnis > 1e-20);
			
			if(ergebnis < 1e-20)
				printf("\nNullstelle gefunden bei %.10f",a);
		}
		
		a += schrittweite;
	}	while(a < obere_grenze);

	return 0;
}

float funktionswert(int *potenz, float *koeffizient, float argument)
{
	float ergebnis = 0;
	int i;

	for(i=0; i<= (*potenz); i++)
	{
		ergebnis	+= koeffizient[i] * (float)pow(argument,i);
	}

	return ergebnis;
}

 

[Arnd]

Bis auf i, a und a_new fast perfekt :-). Zu dem new fehlt noch das delete und die Variablen noch initialisieren.

Auf jeden Fall ist es so wesentlich besser lesbar und man muss deutlich weniger Gehirnschmalz investieren um zu verstehen was das Programm macht.

MfG

Arnd

 

[7H3 N4C3R]

Zu letzterem Programm wäre noch zusagen, dass die Standard-Header in spitze Klammern gehören und new irgendwie nicht so viel mit C zutun hat.