Runden auf 4 signifikante Stellen

Lemontime

Hallo Community

Ich neu in der Welt des Programmierens. Ich suche eine Funktion bei der man Zahlen auf 4 signifikante Stellen runden kann, d.h 0, 7777777777777 -> 0,7778.

Gruss & Danke für eure Hilfe

Lemontime

Es gibt verschiedene Rundungsverfahren

Nimm das von dir gewünschte, schreibe Beispiele auf ein Blatt Papier und setze das in Quelltext um. Versuch das wenigstens.

MfG f.-th.

Lemontime

Ich dachte es gäbe vielleicht schon eine fertige Funktion in die man die Variabeln nur noch einlesen muss.

Auf die Stelle vor dem Komma kann man runden, indem man 0,5 addiert und dann die Nachkommastellen wegstreicht.

Ganz so einfach ist es nicht, darum spiele mal verschiedene Fälle durch.

CJosef

Lemontime schrieb:

Ich dachte es gäbe vielleicht schon eine fertige Funktion in die man die Variabeln nur noch einlesen muss.

Wenn es lediglich um die Ausgabe geht:

double number =  0.77777777;
printf ("%.4lf\n", number);

Dazu guckst du hier für die verschiedenen Möglichkeiten wie man den
Formatstring (format specifier) für printf definieren kann: http://www.cplusplus.com/reference/clibrary/cstdio/printf/

Falls du damit rechnen willst, so dass obige Zahl zu 0.7778 gerundet wird:
gibt es einen guten Grund die Genauigkeit zu verschlechtern?

Ist das so eine Schülerärgeraufgabe, um zu zeigen wie undankbar das Binärsystem sein kann?
Manche Zahlen lassen sich binär nicht exakt darstellen,
http://tutorial.pocoo.org/floatingpoint.html
http://www.arndt-bruenner.de/mathe/scripts/Zahlensysteme.htm

double spoilsport_number = 0.7778;	// Guckst in den Debugger, siehst du: 0.77780000000000005
	spoilsport_number = 0.3; // Guckst in den Debugger, siehst du: 0.29999999999999999
... etc.

darum auch nicht exakt runden.

berniebutt

CJosef schrieb:

Falls du damit rechnen willst, so dass obige Zahl zu 0.7778 gerundet wird ...

Dann kannst du die Funktion round() auf meiner HP http://berniebutt.npage.de herunterladen oder nach etwas anderem suchen.

Lemontime

Ich habe es jetzt so weit gemacht wie es ging nun habe ich das Problem das er bei mir das "pow10" nicht erkennt obwohl es ja im <math.h> enthalten ist an was kann das liegen ?

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

double round(double value,unsigned short np)

{
	double  factor;
	factor = pow10(np);
	return floor(value*factor+0.5)/factor;
}

int main(void)
{
	unsigned short Main_np = 4;
	double value = 0.7777777;
	double res = 0;

	res = round(value, Main_np);

	printf("Das Resultat lautet : %f",res);

	getchar();
	return 0;
}

gigg

Lemontime schrieb:

Ich habe es jetzt so weit gemacht wie es ging nun habe ich das Problem das er bei mir das "pow10" nicht erkennt obwohl es ja im <math.h> enthalten ist an was kann das liegen ?

Das liegt daran, dass es keine pow10-Funktion gibt. In math.h gibt es nur pow().

Lemontime

Nun kommt die Fehlermeldung:
Error: Keine Instanz von Überladene Funktion "pow" stimmt mi der Argumentliste überein.

SeppJ

Lemontime schrieb:

Nun kommt die Fehlermeldung:
Error: Keine Instanz von Überladene Funktion "pow" stimmt mi der Argumentliste überein.

Du nutzt einen C++-Compiler für C. Tu das nicht.

Und lass mal deine Funktion auf negative Werte los.

Lemontime schrieb:

Nun kommt die Fehlermeldung:
Error: Keine Instanz von Überladene Funktion "pow" stimmt mi der Argumentliste überein.

double pow10 ( double exponent )
{
	return pow ( 10, exponent );
}

oder noch besser die round funktion anpassen

berniebutt schrieb:

CJosef schrieb:

Falls du damit rechnen willst, so dass obige Zahl zu 0.7778 gerundet wird ...

Dann kannst du die Funktion round() auf meiner HP http://berniebutt.npage.de herunterladen oder nach etwas anderem suchen.

double num = round ( 4.015, 2 );
printf ("%lf\n", num );

4.010000

SeppJ

Da kann berniebutt nichts für. Die genaueste Repräsentation von 4.015 im gängigen Fließkommaformat ist eine Zahl, die ein kleines bisschen kleiner als 4.015 ist.

berniebutt

Entweder hat der C-Compiler eine solche Funktion double = round(double value, int precision) zu bieten oder die ersatzweise eigene Funktion muss stimmen. Danke für den Bughinweis! Wird korrigiert - morgen gemacht. Oder tobt euch da aus - ist eine gute Übung im Umgang mit Fliesskommazahlen und dem Gebrauch von eps!

long double round(long double value, unsigned short np)
// ---------------------------------------------------------------------------
// round a long double value to a precision of np
// ---------------------------------------------------------------------------
{
   long double  val, val1, val2. val3, result, eps;
   long double  factor,add;

   eps = 0.0000001;
   if(val < 0.000) eps = -eps;
   val = value + eps;

   factor = pow10l(np);
   val1 = floorl(val*factor)/factor;
   val2 = (val - val1) * factor;
   if (val2 > 0.5) add = 1.00;
   else            add = 0.00;
   val3 = val1 + add /factor;

   return val3;
}

Und haut mich!

berniebutt schrieb:

Entweder hat der C-Compiler eine solche Funktion double = round(double value, int precision) zu bieten oder die ersatzweise eigene Funktion muss stimmen. Danke für den Bughinweis! Wird korrigiert - morgen gemacht. Oder tobt euch da aus - ist eine gute Übung im Umgang mit Fliesskommazahlen und dem Gebrauch von eps!

der compiler hat funktionen zu bieten?
oder meinst du die standardbibliothek?

berniebutt

verwirrter schrieb:

der compiler hat funktionen zu bieten?
oder meinst du die standardbibliothek?

Compiler müssen die allgmeinen Standardfunktionen haben und bieten oft mehr. Die Funktion double round(double,int) gehört nicht zu den Standardfunktionen. Die von mir korrigierte Funktion ist toplastig für alte 16/32-bit Compiler ausgerichtet. Eine Anpassung fällt aber nicht schwer. Wer will kann sich mit der Verbesserung gerne austoben und für eine Optimierung über z.B. 10000 Durchläufe etwas Performance herauskitzeln. Das gehört aber nicht mehr unbedingt zum Thema!

berniebutt schrieb:

[cpp]long double round(long double value, unsigned short np)
// ---------------------------------------------------------------------------
// round a long double value to a precision of np
// ---------------------------------------------------------------------------
{
long double val, val1, val2. val3, result, eps;
long double factor,add;

eps = 0.0000001;
if(val < 0.000) eps = -eps;
val = value + eps;

factor = pow10l(np);
val1 = floorl(val*factor)/factor;
val2 = (val - val1) * factor;
if (val2 > 0.5) add = 1.00;
else add = 0.00;
val3 = val1 + add /factor;

return val3;
}
[/cpp]

Täusch ich mich, oder ist dein erster Vergleich direkt mit einer uninitialisierten Variable?

berniebutt

Falsch übernommen - jetzt korrigiert!

berniebutt schrieb:

Falsch übernommen - jetzt korrigiert!