Frage zu sprintf() - Rundung
Thomas Barth
ich möchte Fließkommazahlen auf die 2. Stelle kaufmännisch runden. Mir wird
hier im Buch sprintf() oder printf() angeboten. Da ich aber im Moment die
Ausgabe nicht testen kann, wollte ich fragen, ob die Anwendung dieser
Funktion soweit richtig ist.
use POSIX;
$erente = sprintf("%.2f", ($prozb * $netto)/100);
oder muss ich schreiben:
$erentea = ($prozb * $netto)/100;
$erenteb = sprintf("%.2f", $erentea);
Gruß,
Thomas Barth
Andre Malo
>use POSIX;
>$erente = sprintf("%.2f", ($prozb * $netto)/100);
[oder]
>$erentea = ($prozb * $netto)/100;
>$erenteb = sprintf("%.2f", $erentea);
oehm, ich sehe da inhaltlich keinen Unterschied, der Wert wird in beiden
Faellen ausgerechnet, bevor sprintf ausgefuehrt wird.
n.d.p.
--
die (eval q-qq[Just Another Perl Hacker
]
;-)
# n.d. parker, http://www.o3media.de/ #
Boris 'pi' Piwinger
> ich möchte Fließkommazahlen auf die 2. Stelle kaufmännisch runden. Mir wird
> hier im Buch sprintf() oder printf() angeboten. Da ich aber im Moment die
> Ausgabe nicht testen kann, wollte ich fragen, ob die Anwendung dieser
> Funktion soweit richtig ist.
Hat eigentlich jemand eine gute Dokumentation dafuer? Die Buecher
verweisen auf die Maennchenseiten, diese ist aber ueberhaupt nicht
nuetzlich und info hilft auch nicht.
pi
Martin H. Sluka
Was genau gefällt Dir an "perldoc -f sprintf" nicht?
Evtl. magst Du Appendix A von <http://www.effectiveperl.com/> lesen,
sowieso eines der empfehlenswerteren Bücher.
Martin.
--
______________________________________________________________________
Martin H. Sluka / <mailto:mar...@sluka.de> / <http://martin.sluka.de/>
Samuel Kilchenmann
news:9bk8l7$a0h2d$1...@ID-63233.news.dfncis.de...
> ich möchte Fließkommazahlen auf die 2. Stelle kaufmännisch runden.
Was verstehst du unter "kaufmännisch runden"?
(s)printf rundet so, wie es die verwendete C Laufzeitbibliothek für
"richtig" hält. Die Rundungsergebnisse können je nach verwendeter C
Bibliothek unterschiedlich ausfallen. Beispiel:
(s)printf("%.2f", 1.125) liefert entweder 1.12 oder 1.13 je nachdem,
ob die C Laufzeitbibliothek "round to nearest even" (Un*x, Cygwin),
oder "round away from zero" (MS) implementiert.
Welches Ergebnis sollte "kaufmännisches runden" in diesem Fall
liefern? 1.12 oder 1.13?
> use POSIX;
Das ist für die Verwendung von (s)printf nicht erforderlich.
> $erente = sprintf("%.2f", ($prozb * $netto)/100);
>
> oder muss ich schreiben:
>
> $erentea = ($prozb * $netto)/100;
> $erenteb = sprintf("%.2f", $erentea);
>
Da besteht kein Unterschied.
Thomas Barth
>
> Was verstehst du unter "kaufmännisch runden"?
>
Genau das, was du beschrieben hast. floor oder ceil rundet ja auf ganze
Zahlen auf oder ab, sprintf dagegen berücksichtigt die letzte Zahl zum auf-
oder abrunden. Mehr habe ich darunter nicht verstanden. Irgendwo hatte ich
mal aufgeschnappt, dass dies als kaufmännische Rundung bezeichnet wird :-)
Boris 'pi' Piwinger
> Was genau gefällt Dir an "perldoc -f sprintf" nicht?
Fehlende Beispiele. Und ein Hinweis auf irgendwelche C Funktionen sind
nutzlos. Schliesslich will ich nicht C lernen, um Perl zu nutzen. "See
L<sprintf(3)> or L<printf(3)>
on your system for an explanation of the general principles." halte
ich da -- wie gesagt -- auch nicht fuer den Knaller.
> Evtl. magst Du Appendix A von <http://www.effectiveperl.com/> lesen,
> sowieso eines der empfehlenswerteren Bücher.
Das mag sein. Mit Learning Perl und Programming Perl war ich da
angekommen, wo ich mit perldoc auch immer wieder hinkomme.
Erklaerungen, die genau dann hilfreich sind, wenn man eh alles schon
kann und sich nur die Details in Erinnerung rufen will.
pi
Boris 'pi' Piwinger
> Was verstehst du unter "kaufmännisch runden"?
>
> (s)printf rundet so, wie es die verwendete C Laufzeitbibliothek für
> "richtig" hält. Die Rundungsergebnisse können je nach verwendeter C
> Bibliothek unterschiedlich ausfallen. Beispiel:
> (s)printf("%.2f", 1.125) liefert entweder 1.12 oder 1.13 je nachdem,
> ob die C Laufzeitbibliothek "round to nearest even" (Un*x, Cygwin),
> oder "round away from zero" (MS) implementiert.
>
> Welches Ergebnis sollte "kaufmännisches runden" in diesem Fall
> liefern? 1.12 oder 1.13?
Kaufmaennisch ist dasselbe wie mathematisch;-) Man rundet ab 5 in der
naechsten Stelle auf, sonst ab.
pi
Michael Döring
Genau das ist es. Und um obiges Problem zu umgehen und noch kleineren
Schnickschnack mit Punkten, Kommata und Auffüllen mit 0 nach dem Komma,
hatte ich mal das hier zusammengestrickt:
sub RUNDEN($;$) {
##
## Rundet einen Wert mit beliebig vielen Nachkommastellen
KAUFMÄNNISCH(!)
## auf einen Wert mit der angegebenen Zahl Nachkommastellen.
## Kaufmännisch heißt im Beispiel mit zwei Stellen:
## 3.45 bleibt 3.45
## aus 3.4510000000001 bis 3.4549999999999 wird 3,45
## aus 3.4550000000001 bis 3.4599999999999 wird 3,46
##
## Außerdem werden Dezimalpunkte eingefügt und aus dem
## Dezimalpunkt wird ein Komma gemacht.
## z.B. aus 1234.56 wird 1.234,56 bei 2 Stellen
##
## Die Nachkommastellen werden mit 0 aufgefüllt wenn
## durch den Wert die angegebene Zahl nicht erreicht wird,
## z.B. aus 3.4 wird 3,400 bei 3 Stellen
##
## Wird aufgerufen mit
## $return = &RUNDEN($wert,$stellen);
## wobei $wert die zu rundende Zahl ist
## und $stellen die Anzahl der zu rundenden Nachkommastellen ist
##
## $return enthält dann den gerundeten Wert von $wert
## oder 0 bei Mißerfolg
##
## ACHTUNG: Mit dem Rückgabewert dieser Routine läßt sich NICHT mehr
RECHNEN!
##
my ($val,$dec) = @_;
return 0 if ((!defined $val) || (!defined $dec) || ($val=~ /[^-0-9\.]/)
||($dec=~ /[^-0-9]/) || ($dec<0) || ($dec>10));
my $neg = 0;
if ($val<0) {$val=$val*-1;$neg = 1} # Vorzeichen raus sonst stimmt
die Rechnung nicht
$val = (($val + (0.5/(10**$dec)))*100)/100; # mathematisch aufrunden
my $res = int($val*(10**$dec))/(10**$dec); # Nachkommastellen
abschneiden
$res =~ y/./,/; # ordentlich formatieren
my ($vor,$nach) = split(/,/,$res); # Vor-/Nach-Komma trennen
1 while $vor =~ s/(\d)(\d\d\d)\b/$1.$2/; # Tausenderpunkte
$nach = '' if !defined $nach; # wenn keine Nachkommastellen
while (length($nach)<$dec) {$nach.='0'} # ggfs. Nullen anhängen
$vor = '-'.$vor if $neg; # ggfs. Vorzeichen wieder rein
return $dec ? "$vor,$nach" : $vor; # ggfs. zusammenbauen
}
--
Michael Döring ~~~~~~ Postfach 3143 ~~~~~~ 53831 Troisdorf
Tel: 02241 978197 ~~~ eMail: in...@RPV.de ~~~ ICQ: 12860386
DAS Newsletterprogramm für Ihre Homepage: www.RPV.de/demo/
Mona Wuerz
<in...@rpv.de> wrote:
Michael Döring <in...@rpv.de> wrote:
> Genau das ist es. Und um obiges Problem zu umgehen und noch kleineren
> Schnickschnack mit Punkten, Kommata und Auffüllen mit 0 nach dem Komma,
> hatte ich mal das hier zusammengestrickt:
Hm. Mal sehen ob sich da was machen laesst..
(RUNDEN kommt bspw. mit den letzten beiden Zeilen nicht zurecht. Mit ''
auch nicht.)
#!:perl -w
use strict;
sub RUNDEN($;$) {
require <9bnpt5$cub$1...@news.netcologne.de>; # ;-)
}
sub runden2 {
my ($num, $prc) = @_;
$num = eval {local $^W; $num+0 ? $num : 0}; # Toleranz!
$prc = eval {local $^W; $prc+0 ? $prc : 0};
$_ = reverse sprintf "%.*f", $prc, $prc > 0 ? $num :
(sprintf "%.1f", $num * 10**($prc-1)) * 10**(1-$prc);
s/(\d{3})(?=\d)(?!\d*\.)/$1,/g; # aus perlfaq5
tr/.,/,./;
scalar reverse;
}
my ($num, $prec, $mw, $md);
printf "%10s | %-20s | %-20s\n", 'Stellen', 'RUNDEN()', 'runden2()';
while (defined ($num = <DATA>)) {
print $num; chomp $num;
foreach $prec (-2..2) {
$md = RUNDEN($num, $prec);
$mw = runden2($num, $prec);
printf "%10s | %-20s | %-20s\n", $prec, $md, $mw;
}
}
__DATA__
-9999.9999
5555.5555
+.5
-.05
-mona
Jürgen Exner
news:vfitk0u...@mail.Uni-Mainz.DE...
> Die eigentlich viel interessantere Frage, was nämlich mit 3.455, oder
> - noch interessanter - 3.445, passiert, beantwortest Du hier
> allerdings nicht.
Da sagt aber DIN etwas zu (sorry, habe die Nummer gerade nicht im Kopf):
- wenn die 5 durch eine fruehere Aufrundung enstanden ist dann wird
abgerundet
- wenn die 5 durch eine fruehere Abrundung entstanden ist dann wird
aufgerundet
- wenn die 5 exakt ist (und es absolut keine weiteren Stellen != 0 gibt)
dann wird abgerundet (das machen die meisten Leute falsch)
- wenn es nach der 5 noch irgendwo eine weitere Ziffer !=0 gibt wird
aufgerundet.
jue
Michael Döring
>Hm. Mal sehen ob sich da was machen laesst..
>(RUNDEN kommt bspw. mit den letzten beiden Zeilen nicht zurecht. Mit ''
>auch nicht.)
OK, mit der vorletzten (+.5) habe ich Probleme. Stimmt. Da jedoch
bisher alle Werte aus Berechnungen stammten, brauchte ich nicht auf ein
+ reagieren. Dies gibt es nämlich (zumindest in meiner Perl-Version)
nicht.
Mit der letzten (-.05) habe ich offensichlich auch einen großen Fehler
übersehen <DUCK_RUNTER>
>#!:perl -w
>use strict;
>
>sub RUNDEN($;$) {
>
> require <9bnpt5$cub$1...@news.netcologne.de>; # ;-)
>
>}
>
>sub runden2 {
> my ($num, $prc) = @_;
> $num = eval {local $^W; $num+0 ? $num : 0}; # Toleranz!
> $prc = eval {local $^W; $prc+0 ? $prc : 0};
> $_ = reverse sprintf "%.*f", $prc, $prc > 0 ? $num :
> (sprintf "%.1f", $num * 10**($prc-1)) * 10**(1-$prc);
> s/(\d{3})(?=\d)(?!\d*\.)/$1,/g; # aus perlfaq5
> tr/.,/,./;
> scalar reverse;
>}
>
>my ($num, $prec, $mw, $md);
>
>printf "%10s | %-20s | %-20s\n", 'Stellen', 'RUNDEN()', 'runden2()';
>
>while (defined ($num = <DATA>)) {
> print $num; chomp $num;
> foreach $prec (-2..2) {
^^
Watt soll datt denn sein?
Wie rundet man auf -2 bzw. -1 Stellen?
Ist das Abschneiden vor dem Komma oder bin jetzt ein bißchen malle?
> $md = RUNDEN($num, $prec);
> $mw = runden2($num, $prec);
> printf "%10s | %-20s | %-20s\n", $prec, $md, $mw;
> }
>}
Deine Routine wurde assimiliert, Widerstand ist zwecklos :-)
Gruß und besten Dank
Michael Döring
Wo auch immer das steht, wir möchten hier kaufmännisch runden!
Und genau das ist die Bedeutung dieses Adjektivs.
Beim kaufmännischen Runden interessieren frühere Rundungen nicht.
Michael Döring
>Michael Döring <in...@rpv.de> writes:
>>## Rundet einen Wert mit beliebig vielen Nachkommastellen
>>KAUFMÄNNISCH(!)
>>## auf einen Wert mit der angegebenen Zahl Nachkommastellen.
>>## Kaufmännisch heißt im Beispiel mit zwei Stellen:
>>## 3.45 bleibt 3.45
>>## aus 3.4510000000001 bis 3.4549999999999 wird 3,45
>>## aus 3.4550000000001 bis 3.4599999999999 wird 3,46
>
>- noch interessanter - 3.445, passiert, beantwortest Du hier
>allerdings nicht.
Probier es doch selbst aus.
Ich wüßte auch nicht, warum das beim kaufm. Runden einen Unterschied
ergeben sollte.
Mona Wuerz
> "Mona Wuerz" <wu...@yahoo.com> schrieb:
>
> > foreach $prec (-2..2) {
> ^^
> Watt soll datt denn sein?
> Wie rundet man auf -2 bzw. -1 Stellen?
> Ist das Abschneiden vor dem Komma oder bin jetzt ein bißchen malle?
Hast Du's probiert?
Beschraenkung auf "positive Anzahl Nachkommastellen" erschien mir
willkuerlich und die Erweierung in die andere Richtung nur konsequent:
runden2( 55.55, 1 ); # 55.6
runden2( 55.55, 0 ); # 56
runden2( 55.55, -2 ); # 100
runden2( 55.55, -3 ); # 0
Noch sinnvoller (in meiner Denkweise -- bin allerdings auch kein
Kaufmann) waere natuerlich die Angabe von signifikanten anstatt
"Nachkomma-" Stellen, in etwa so:
runden_x( 55.55, 3 ); # 55.6
runden_x( 55.55, 1 ); # 60
Die Beziehung zwischen beiden sollte offensichtlich sein.
> Deine Routine wurde assimiliert, Widerstand ist zwecklos :-)
Richtig begeistert bin ich noch nicht, vor allem das
sprintf(.., sprintf(..)) sieht mir aus als haette ich noch das eine
oder andere Brett vorm Kopf.
Andere Vorschlaege erwuenscht.
-mona
Samuel Kilchenmann
news:210420010013260779%wu...@yahoo.com...
>
> Noch sinnvoller (in meiner Denkweise -- bin allerdings auch kein
> Kaufmann) waere natuerlich die Angabe von signifikanten anstatt
> "Nachkomma-" Stellen, in etwa so:
>
> runden_x( 55.55, 3 ); # 55.6
>
printf("%.3g", 55.55);
Auch Kaufleute erwarten allerdings kaum, dass das effektiv 55.5
liefert. (Dahinter stecken diesmal die "Wunder" der binären
Fliesspunkt-Arithmetik und nicht die je nach Plattform
unterschiedlichen Rundungsmodi der C Bibliothek, die bewirken, dass
z.B. printf("%.1g", 2.5) auf der einen Maschine (Un*x) 2 liefert und
auf einer anderen Maschine (MS) 3.
>
> Richtig begeistert bin ich noch nicht, vor allem das
> sprintf(.., sprintf(..)) sieht mir aus als haette ich noch das eine
> oder andere Brett vorm Kopf.
>
> Andere Vorschlaege erwuenscht.
>
urspüngliche Variante liefert z.B. für den Aufruf runden2(250, -2)
entweder 200, oder 300, je nachdem, ob ich auf demselben PC entweder
ActivePerl, oder Cygwin Perl verwende. Deshalb würde ich deine Routine
so umschreiben:
sub runden2 {
my ($num, $prc) = @_;
{
local $^W;
$num = $num + 0; # Toleranz!
$prc = $prc + 0;
}
my $fix = ($num < 0) ? -0.5 : 0.5;
my $m = 10 ** $prc;
local $_;
$_ = reverse(sprintf("%.*f", $prc, int($num * $m + $fix) / $m));
s/(\d{3})(?=\d)(?!\d*\.)/$1,/g; # aus perlfaq5
tr/.,/,./;
return scalar reverse($_);
}
Was spricht gegen das CPAN Modul Math::Round?
Martin H. Sluka
> sub runden2 {
> my ($num, $prc) = @_;
> $num = eval {local $^W; $num+0 ? $num : 0}; # Toleranz!
> $prc = eval {local $^W; $prc+0 ? $prc : 0};
Wieso eval? Ich denke, Du meinst eher do. Wobei ich eine Zusammenfassung
zu einem Block eh für geschickter halte, da es die doppelte Lokalisie-
rung von $^W spart:
sub runden2($$) {
my($num, $prc) = @_;
{
local $^W;
$_ = $_+0 ? $_ : 0 for $num, $prc
}
BTW, würde nicht auch eine bedingte Zuweisung, also
$_+0 or $_ = 0 for $num, $prc
reichen? (Ich muss gestehen, mir ist die Magie hinter Deinen Operationen
hier möglicherweise noch nicht ganz bewusst.)
> $_ = reverse sprintf "%.*f", $prc, $prc > 0 ? $num :
^^
Ich denke, das möchtest Du an der Stelle auch lokalisieren;
no UnderScore;
Mona Wuerz
> Mona Wuerz <wu...@yahoo.com> schrieb:
>
> > $num = eval {local $^W; $num+0 ? $num : 0}; # Toleranz!
>
> Wieso eval? Ich denke, Du meinst eher do. Wobei ich eine Zusammenfassung
> zu einem Block eh für geschickter halte, da es die doppelte Lokalisie-
> rung von $^W spart:
Stimmt, dachte mir schon, dass das zu umstaendlich war.
> > $_ = reverse sprintf "%.*f", $prc, $prc > 0 ? $num :
> ^^
> Ich denke, das möchtest Du an der Stelle auch lokalisieren;
>
> no UnderScore;
Das hingegen verstehe ich nicht. Ich verwende $_ (dessen vorheriger
Inhalt hier uninteressant ist) nur, um spaeter tr/// et al. an Stelle
von $x =~ tr/// schreiben zu koennen (und habe das schon oft so ohne
erkennbaren Nebeneffekte gemacht). Sollte das gefaehrlich sein wuerde
ich gerne wissen warum.
-mona
Mona Wuerz
> "Mona Wuerz" <wu...@yahoo.com> schrieb im Newsbeitrag
> news:210420010013260779%wu...@yahoo.com...
> >
> > Noch sinnvoller (in meiner Denkweise -- bin allerdings auch kein
> > Kaufmann) waere natuerlich die Angabe von signifikanten anstatt
> > "Nachkomma-" Stellen, in etwa so:
> >
> > runden_x( 55.55, 3 ); # 55.6
> >
> Dafuer ist das "g" Format von (s)printf gedacht.
> printf("%.3g", 55.55);
So wie ich die Dokumentation von sprintf verstehe nicht. "g" ist
dasselbe wie "e" oder "f" je nach absoluter Groesse der Zahl. Und meine
Funktion verwendet schon "f", ich koennte dann nur explizit "e"
vorgeben.
> Auch Kaufleute erwarten allerdings kaum, dass das effektiv 55.5
> liefert.
> [printf systemabhaengig]
Ah, ich vermutete sowas.
> ActivePerl, oder Cygwin Perl verwende. Deshalb würde ich deine Routine
> so umschreiben:
> my $fix = ($num < 0) ? -0.5 : 0.5;
> my $m = 10 ** $prc;
> local $_;
Das verstehe ich nicht so ganz. Ich las auch gerade dasselbe von
Martin. Ist $_ innerhalb von Bloecken nicht automatisch immer
local'isiert?
> $_ = reverse(sprintf("%.*f", $prc, int($num * $m + $fix) / $m));
Stimmt, hier wird sprintf nur noch zur Formatierung verwendet. Ich nahm
an (hoffte), dass sprintf systemunabhaengiger ist, ermutigt von
perlfaq4:
"For rounding to a certain number of digits, sprintf() or printf()
is usually the easiest route."
Sieht aus als haette ich zu kurz gedacht.
> Was spricht gegen das CPAN Modul Math::Round?
In der Praxis nichts. Mir geht's momentan nur um Sport (und Michael D.
kann Module nicht leiden).
-mona
Mona Wuerz
> Ist $_ innerhalb von Bloecken nicht automatisch immer
> local'isiert?
Ok, nachgedacht, probiert und begriffen. Tut es sinnvollerweise nur bei
foreach, map und grep, sonst nicht. Wieder was gelernt.
-mona
Samuel Kilchenmann
> "Samuel Kilchenmann" <skil...@swissonline.ch> wrote:
>
> > "Mona Wuerz" <wu...@yahoo.com> schrieb im Newsbeitrag
> > news:210420010013260779%wu...@yahoo.com...
> > >
> > > Noch sinnvoller (in meiner Denkweise -- bin allerdings auch kein
> > > Kaufmann) waere natuerlich die Angabe von signifikanten anstatt
> > > "Nachkomma-" Stellen, in etwa so:
> > >
> > > runden_x( 55.55, 3 ); # 55.6
> > >
> > Dafuer ist das "g" Format von (s)printf gedacht.
> > printf("%.3g", 55.55);
>
> So wie ich die Dokumentation von sprintf verstehe nicht.
>
Hinsicht wirklich schlecht (das in diesem Thread erwähnte Buch
"Effective Perl Programming" von J. N. Hall hilft auch nicht weiter).
Der entscheidende Punkt ist, wie beim Format "g" die precision
interpretiert wird. Aus der Cygwin sprintf man page:
o prec
an optional field; if present, it is introduced with ` .'
(a period). This field gives the maximum number of charac-
ters to print in a conversion; the minimum number of dig-
its of an integer to print, for conversions with type d,
i, o, u, x, and X; the maximum number of significant dig-
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
its, for the g and G conversions; or the number of digits
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
to print after the decimal point, for e, E, and f conver-
sions.
Aus einem Entwurf des ISO C Standards:
g,G A double argument representing a floating-point
number is converted in style f or e (or in style F
or E in the case of a G conversion specifier), with
the precision specifying the number of significant
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
digits.
^^^^^^
>
> "For rounding to a certain number of digits, sprintf() or
> printf() is usually the easiest route."
>
Das ist leider ein zentraler Teil der Perl Folklore ...
Diesen MS Artikel zum Thema Runden finde ich ziemlich interessant:
Deutsch:
http://www.microsoft.com/intlkb/germany/support/kb/D44/D44055.htm
Englisch:
http://support.microsoft.com/support/kb/articles/Q196/6/52.ASP
Meine Hoffnung ist daneben, dass in den Scriptsprachen der Zukunft
eine dezimale Fliesspunkt-Arithmetik implementiert werden wird, z.B.
sowas, wie es schon lange in Rexx implementiert ist und wie es hier
für Java beschrieben wird:
http://www2.hursley.ibm.com/decimal/decimald.html
Mona Wuerz
> [ueber sprintf und %g]
Danke fuer die Erklaerung. Ich habe mir inzwischen auch andere
'Sprachen' (Igor, TestPoint) angesehen, die an c angelehntes printf
verwenden, und deren Dokumentation sagt genau dasselbe (g ->
significant digits). Perls Dokumentation laesst da tatsaechlich zu
wuenschen uebrig, war mir nie so bewusst.
-mona