Runden @ PS-Trainer

Runden
Ohne weitere Angaben versteht man unter dem Begriff 'Runden' meist ► Die Berechnung der nächst-liegenden ganzen Zahl aus einer Gleitkomma-Zahl. In der Praxis werden jedoch auch viele andere Rundungen durchgeführt, z.B. auf 2 Dezimalstellen (€), auf ganze 10er, 1000er, usw. • Das Ziel ist stets, einen Zahlenwert in einem Text mit dem kleinsten möglichen Fehler darzustellen.	Man beschreibt 'Runden' am besten durch praktische Angaben, z.B. der gewünschten Ziffern (Stellen) oder Dezimalsziffern. Theoretische Definitionen sind mehr oder weniger unverständlich, sinnvolle mathematische nicht zu finden. • Unterscheiden sie zwischen dem Runden zum Rechnen (nur selten sinnvoll) und dem Runden zur Darstellung in der Ausgabe (immer sinnvoll). • Im Gegensatz zum → Abschneiden (Funktionen ceil(), floor(), int() ) ist der beim Runden wegfallende Rest meist uninteressant.
Runden auf ganze Zahlen Diese Funktion berechnet die nächst-liegende ganze Zahl. • Die Rundung erfolgt immer symmetrisch zum Nullpunkt x=0, daher ist round(-3.141592) = -3 round(+3.141592) = +3 ♣ Die Rundungs-Funktion verlangt manchmal die Angabe des Nachkomma-Stellen als 2. Argument. In diesem Fall gibt man 0 Stellen an: round(+3.141592,0) = 3	• Wenn der Nachkomma-Teil genau 0.5 beträgt, dann ist der Abstand zur nächst-kleineren ganzen Zahl gleich groß wie zur nächst-größeren. In diesem Fall wird nomalerweise auf die nächst-größere (absolute) Zahl gerundet. Das ist zwar allgemein üblich und in vielen Staaten durch Verordnungen festgelegt, jedoch nicht mathematisch zwingend. round(-0.499) = 0 round(-0.500) = -1 round(+0.499) = 0 round(+0.500) = 1
Aufrunden und Abrunden sind Sonderformen und werden manchmal als eigene Funktionen angeboten. Dabei wird im Gegensatz zu allen anderen Rundungs-Varianten die Richtung vorgegeben, in welcher das Ergebnis zu suchen ist.	Vergleichen sie dazu die → Abschneide-Funktionen ceil(), floor() und int()
Runden auf Nachkomma-Stellen Dazu wird die Anzahl der gewünschten Nachkomma-Stellen angegeben. Damit sind ohne weitere Angaben Dezimal-Stellen gemeint. Währung Im kommerziellen Bereich wird meist auf 2 Nachkomma-Stellen gerundet, weil man damit die kleinste Einheit der jeweiligen Währung darstellt. Für den Geschäftsverkehr ist die Rundung meist gesetzlich geregelt. ♣ Faustregel für die Informatik: Man rechnet stets mit maximaler Genauigkeit und rundet erst das End-Ergebnis auf 2 Stellen. Beispiel: Nettopreis: 1.23456789 20% MWSt. 0.24691358 Bruttopreis: 1.48148147 round(mwst,2) = 0.25 round(brutto,2) = 1.48 Wenn es um große Stückzahlen geht, werden Einzelpreise mit mehr Nachkomma-Stellen angegeben, und erst das Ergebnis gerundet, z.B. Einzelpreis: 1.234567 € Preis für 100 Stück round(123.4567,2) = 123.46	End-Ziffern Es ist möglich, auf eine Auswahl bestimmter End-Ziffern zu runden. Beispiel: Die mit unserem wirtschaftlichen System zwangsläufig verbundene Inflation hat den Euro-Cent schon unmittelbar nach seiner Einführung wertlos gemacht. Deshalb wird meist nur mehr auf 5 Cent gerundet. • Runden eines Betrags x auf 0 oder 5 Cent: n = 0.05 r = round(x/n, 0) * n Mit n=0.02 wird auf eine der End-Ziffern {0,2,4,6,8} gerundet, mit n=0.5 auf 50 Cent, d.h. 1 Nachkomma-Stelle aus {0,5} usw. ♣ Für n sind nur Zahlenwerte mit der End-Ziffer 2 oder 5 sinnvoll. Wissenschaft Im technischen und naturwissenschaftlichen Bereich bevorzugt man oft die Darstellung mit 3 oder 6 Stellen, weil die Einheiten in 1000er-Schritten abgestuft sind, z.B. die Länge in mm, m, km Dabei wird jedoch nicht mit gerundeten Zahlen gerechnet, sondern lediglich die Ausgabe entsprechend formatiert. • Die Darstellung im 'wissenschaftlichen Format' (z.B. 1.23E+123) kombiniert eine gerundete → Mantisse mit einem ganzzahligen dezimalen → Exponenten.
Runden auf <0 Stellen Größere Zahlen werden in der Praxis oft auf eine bestimmt Anzahl von signifikanten Ziffern gerundet. Man gibt z.B. nur die ersten 3 Ziffern an und rundet alle weiteren auf Nullen. In der Praxis wird häufig auf Tausender (-3), Millionen (-6), Milliarden (-9) gerundet.	Dazu verwendet man die Rundungs-Funktionen mit Angabe von <0 Dezimalstellen als 2. Argument, z.B. x = 1234567.89 round(x, 0) = 1234568 round(x,-1) = 1234570 round(x,-3) = 1235000 round(x,-6) = 1000000
Grenzen der Informatik Es ist wenig bekannt, dass ein PC ohne besondere Angaben meist 'nur' auf ca. 16 Dezimalstellen genau rechnet. Es ist daher unabhängig von der Anzahl der Nachkomma-Stellen sinnlos, mehr als 16 Ziffern einer Zahl anzugeben. Beispiel: Diese Additionen sind sinnlos und das Ergebnis mathematisch falsch: 1234567890123456 + 1 ≠ 1234567890123456 12345678901234.56 + 0.01 ≠ 12345678901234.56	Beim Rechnen mit Gleitkomma-Zahlen werden intern binäre Zahlen verwendet. Für eine → Gleitkomma-Zahl stehen normalerweise 53 Bit Speicherplatz zur Verfügung. Die maximale (relative) Genauigkeit beträgt daher ca. 2^(-53) ≃ 1E-16 oder 16 Dezimal-Ziffern. Es spielt keine Rolle, wie diese maximal 16 Ziffern links oder rechts vom Dezimalpunkt (oder -Komma) angeordnet sind. • Mit speziellen Methoden kann man auch in der Informatik mit beliebiger Genauigkeit rechnen. Diese stehen jedoch in normalen Büro-Programmen nicht zur Verfügung. Moderne Programmiersprachen bieten dazu eigene Module, z.B. bignum für Perl, BC-Math oder GMP für PHP. ♦ Details zu Zahlen, speziall Gleitkomma-Zahlen in der Informatik
Fehler-Fortpflanzung Ein eigenes Arbeitsgebiet der Mathematik bzw. Statistik beschreibt die Fehler-Rechnung und Fehler-Fortpflanzung. Hier werden dazu keine Details angegeben, es wird jedoch darauf hingewiesen, dass man beim Runden Fehler in Kauf nehmen muss. 'Freiwillige' Rundung Wenn man mit einer gerundeten Zahl weiter rechnet, dann unterliegt der Fehler den gleichen Algorithmen wie das 'eigentliche' Ergebnis. Beispiel: x = 12.34567 round(x,2) = 12.35 y = x * 1000 = 12350 Man kann das Ergebnis ebenfalls runden: round(y,2) = 12350.00 Der mittlere Fehler beträgt jedoch nicht Δy=0.005 wie man aus der 2.Rundung erwarten könnte, sondern wegen der Fortpfanzung des Fehlers Δy=5 ♣ Runden sie beim Rechnen niemals ohne wichtigen Grund. Runden sie nur das End-Ergebnis.	Zwangsläufige Rundung Gleitkomma-Zahlen werden intern nur mit 53 Bit ≃ 15-16 Dezimal-Stellen Genauigkeit gespeichert. Das Ergebnis jeder Rechnung wird daher ungefragt und unvermeidlich auf diese Genauigkeit gerundet. Wenn man längere Ketten von Rechnungen ausführt, dann wird die Genauigkeit des End-Ergebnisses durch die Rundungs-Fehler jeder einzelnen Teil-Rechnung bestimmt. Hier wird nicht auf die mathematischen Details der Fehler-Fortpflanzung eingegangen. ♣ Faustregel: Der Rundungs-Fehler spielt immer dann eine wichtige Rolle, wenn diese Indizien zutreffen: • Berechnung einer kleinen Differenz zwischen 2 fast gleich großen Zahlen. • Mit der Differenz wird anschließend weiter gerechnet, sie wird z.B. mit großen Zahlen multipliziert. Wenn solche oder ähnliche Fälle auftreten, dann kann man den Fehler manchmal durch Änderung oder mathematische Umstellung des Algorithmus verringern.
Rundung bei der Ausgabe Alle Kalkulations-Programme und Programmiersprachen bieten Funktionen zum Runden. Diese sollte man jedoch ohne wichtige Begründung nicht im Laufe von Rechnungen verwenden.	Die Ergebnisse sollen übersichtlich sein und nur so viele Details enthalten, wie für die jeweilige Anwendung sinnvoll sind. Daher werden Ausgabe-Daten fast immer gerundet. Dazu werden jedoch andere Funktionen verwendet, die folgerichtig auch keine Zahlen zurückgeben.

Runden mit Kalkulations-Programmen

Funktion RUNDEN()

Alle Standard Kalkulations-Programme (LibreOffice-Calc, MS-Excel, ...) bieten diese Funktion.
Sie erwartet als 1. Argument die zu rundende Zahl, als 2. Argument die Anzahl der Nachkomma-Stellen.

Klicken sie im Kalkulations-Programm die Taste F9, hier den gleichnamigen Button, um das Beispiel Live mit einer neuen → Zufallszahl im Bereich -100...x...+100 anzuzeigen.

Runden von Gleitkomma-Zahlen:

	A	B
1	x	=ZUFALLSZAHL()*200-100	31.41592
2	Stellen	Ergebnis
3	2	=RUNDEN($B$1;$A3)	31.42
4	=A3-1	=RUNDEN($B$1;$A4)	31.4
5	=A4-1	=RUNDEN($B$1;$A5)	31
6	=A5-1	=RUNDEN($B$1;$A6)	30
7	=A6-1	=RUNDEN($B$1;$A7)	0

Die Zellen der Spalte B werden hier 2mal dargestellt:
Links mit der darin eingetragenen Formel, rechts mit dem Live berechneten Ergebnis.

Funktion ABRUNDEN()

Diese Funktion ist nur in neueren Versionen der Kalkulations-Programme verfügbar. Man kann sie durch die rechts angegebene Formel ersetzen, die in allen Versionen funktioniert.

Formel zum Abrunden einer Zahl aus Zelle B1 mit Anzahl der Nachkomma-Stellen aus Zelle A3

= (GANZZAHL($B$1 * 10^$A3) + WENN(UND($B$1<0; REST($B$1 * 10^$A3;1)>0); 1; 0)) / (10^$A3)

Wenn sie diese Formel in eine Zelle des Demo-Beispiels (z.B. in C3) einsetzen, dann liefert sie das gleiche Ergebnis wie

=ABRUNDEN($B$1;$A3)

Funktion AUFRUNDEN()

Diese Funktion ist nur in neueren Versionen der Kalkulations-Programme verfügbar. Man kann sie durch die rechts angegebene Formel ersetzen, die in allen Versionen funktioniert.

Formel zum Aufrunden einer Zahl aus Zelle B1 mit Anzahl der Nachkomma-Stellen aus Zelle A3

= (GANZZAHL($B$1 * 10^$A3) + WENN(UND($B$1>0; REST($B$1 * 10^$A3;1)>0); 1; 0)) / (10^$A3)

Wenn sie diese Formel in eine Zell des Demo-Beispiels (z.B. in D3) einsetzen, dann liefert sie das gleiche Ergebnis wie

=AUFRUNDEN($B$1;$A3)

Die allgemeinen Formeln zum Ersatz von ABRUNDEN() und AUFRUNDEN() sind unerwartet komplex (und ohne Gewähr !).

Die Entwicklung solcher Formeln ist eine Aufgabe für Fortgeschrittene. Spezielle Lösungen nur für positive Argumente (in B1) oder nur für ganze Zahlen (A5=0) sind wesentlich einfacher.

Runden auf End-Ziffern

Das Beispiel zeigt die Umsetzung des ↑ oben beschriebenen Algorithmus, mit dem eine Zahl auf eine begrenzte Auswahl von End-Ziffern gerundet wird.
Mit n=0.5 werden die Nachkomma-Stellen auf 0.0 oder 0.5 gerundet.

Runden auf ausgewählte End-Ziffern:

	A	B
1	x	=ZUFALLSZAHL()*200-100	31.41592
...
8	n	Ergebnis
9	0.5	=RUNDEN($B$1/$A9;0)*$A9	31.5

Runden auf Stunden oder Minuten

Datum und Zeit wird in Kalkulations-Programmen und Basic gemeinsam als Gleitkomma-Zahl ( → Y1900-System) verwaltet.
Mit den beiden rechts gezeigten Formeln kann man auf die nächst-liegende volle Stunden bzw. Minute runden.

Anwendung (links die Formeln, rechts die Zahlenwerte):

	A		B
1	=JETZT	2012-04-01 13:19:12	=A1	41000,555
2	=RUNDEN(A1*24;0)/24	2012-04-01 13:00:00	=A2	41000,54167
3	=RUNDEN(A1*1440;0)/1440	2012-04-01 13:19:00	=A3	41000,55486

In den Spalten A und B sind die gleichen Zahlen-Werte enthalten. Spalte A ist jedoch mit dem Format "JJJJ-MM-TT hh:mm:ss" formatiert, Spalte B mit "Standard"

Format

In jedem Fall sollte man die Ergebnisse von Kalkulationen in übersichtlicher, leicht verständlicher Form anzeigen. Dazu trägt besonders das Format der angezeigten Daten bei.

Je nach Programm kann man zur Formatierung unterschiedliche Menü-Befehle verwenden.

Mit Rechtsklick in eine Zelle gelangt man in jedem Programm zu den Formatierungs-Optionen !

Funktion TEXT()

Diese Funktion dient zur Umwandlung einer Zahl in einen Text (String).

Beispiel:

=TEXT(A1;"0,0")

Diese Funktion wandelt die Zahl aus Zelle A1 in einen Text mit 1 Nachkomma-Stelle um.

• Die Funktion ergibt alleinstehend keinen Sinn - Zur Formatierung einer Zelle ist das Menü besser geeignet. Man verwendet sie, um mit der formatierten Zahl einen Text zusammenzustellen, z.B.

="Ergebnis=" & TEXT(A1;"0,0")

So kann man ein Ergebnis mit einem erklärenden Text versehen. Je nach Ergebnis-Wert kann man den Text mit bedingten Verzweigungen (WENN() ) sogar variabel gestalten.

• Das 1. Argument der Funktion TEXT() ist die zu formatierende Zahl, bzw. eine Adresse, an welcher die Zahl zu finden ist.

• Das 2. Argument ist ein 'Format-String', welcher angibt, wie die Zahl darzustellen ist.

Als Hilfe kann das Menü dienen, in dem meist einige Format-Strings vorgegeben sind. Im Format-String verwendet man die Zeichen 0 oder # als Platzhalter für Ziffern, z.B.

Format-String	Beispiel	Anmerkung
"Standard"	3141,592654	Standard-Format
"0"	3141	Ganze Zahl
"000000"	003141	Führende Nullen
"0,0"	3141,6	1 Nachkomma-Stelle
"0,000"	3141,593	3 Nachkomma-Stellen
"#.##0,00"	3.141,59	Tausender-Punkt
"0,000E+00"	3,142E+03	Wiss.Format
"x=0"	x=3141	Zusatz-Text

♣ Jeder nicht als Format-String erkennbare Text wird genauso ausgegeben, z.B. ein String "x=" als Prefix. Man darf jedoch keine Zeichen verwenden, die im Format eine besondere Bedeutung haben, z.B. für Datum oder Uhrzeit. Sicherer ist z.B. die Formel

="Länge = " & TEXT(A1;"0,00") & "m"

mit einem Ergebnis wie

Länge = 3,14m

Funktion WECHSELN()

Diese Funktion bewirkt den Austausch von Zeichen in einem Text (String). Man kann sie u.a. zur Umwandlung der Dezimal-Trennzeichen verwenden.

• Weltweit und in allen Programmiersprachen (und in diesem Web) wird ein Komma-Punkt verwendet.
• Nur im deutschsprachigen Raum wird ein Komma-Beistrich verwendet. In manchen Regionen wird je nach Anwendung ein unterschiedliches Dezimal-Zeichen gewählt.

Dieses Chaos verursacht nur dann keine Probleme, wenn man Daten gar nicht oder nur im engsten geografischen Umfeld austauscht.
In der heutigen Welt ist das global uneinheitliche Dezimal-Zeichen Anlass für viele Probleme, Fehler und hohe Kosten.

Import von Zahlen mit Dezimal-Punkt

Je nach Programm und Version erkennt das Kalkulations-Programm das Problem und wandelt die Daten automatisch in brauchbare Zahlen.
• Wenn importierte Werte rechtsbündig angezeigt werden, dann hat das mit großer Wahrscheinlichkeit funktioniert.
• Wenn nicht, dann tauscht man das Dezimal-Zeichen und wandelt den geänderten Text in eine Zahl um, z.B.:

A1 = "123.456"
A2 = WECHSELN(A1,".";",")
A3 = WERT(A2)

Export von Zahlen mit Dezimal-Punkt:

Man wandelt jede Zahl in einen Text um und tauscht das Dezimal-Zeichen., z.B.

B1 = 123,456
B2 = TEXT(B1;"Standard")
B3 = WECHSELN(B2;",";".")

Runden mit Basic (LibreOffice-Basic, Visual Basic VBA)

Ein Interpreter für diese Programmiersprache ist in jedem Standard Kalkulations-Programm (LibreOffice-Calc, MS-Excel, ...) enthalten.
Da auf den meisten Arbeits-PC mit einem Office-Paket auch ein Kalkulations-Programm installiert ist, kann man Basic einfach und ohne zusätzliche Programme verwenden.

Basic-Funktionen sind portabel, d.h. man kann den Quelltext der Funktionen ohne Änderung im Basic-Modul jedes Standard Kalkulations-Programm verwenden.

♦ Details zu Basic und zur Einbindung von Basic-Funktionen in Kalkulations-Programme

Funktion Round()

ist leider nur in MS Visual Basic verfügbar, nicht in LibreOffice-Basic oder OpenOffice-Basic.

Sie arbeitet ähnlich wie die Funktion =RUNDEN() von Kalkulations-Programmen, jedoch nur für eine positive Anzahl von Stellen digits>=0

Runden mit Basic

In Kalkulations-Programmen verwendet man die Standard-Funktion RUNDEN(), man braucht dazu keine Basic-Funktion.

Zur internen Verwendung in Basic muss man das Runden jedoch selbst programmieren. Wenn sichergestellt ist, dass nur positive Argumente x>=0 vorliegen, dann kann man so auf ganze Zahlen runden:

x = Int(x + 0.5)

Das Beispiel rechts zeigt eine Basic-Funktion zum Runden einer Gleitkomma-Zahl x auf digits Nachkomma-Stellen. Das Argument digits ist optional und wird bei Bedarf selbst gerundet.
Die Funktion arbeitet auch mit negativen Argumenten von x oder digits so wie erwartet.

Basic-Funktion zum Runden einer Gleitkomma-Zahl x auf digits Stellen:

Function my_round( _

x As Double, Optional digits As Variant) _ As Double

Dim isgn As Integer
Dim d As Double

If IsMissing(digits) Then digits = 0 digits = CInt(digits)
isgn = 1
If (x < 0) Then

x = -x
isgn = -1

End If
d = 10 ^ digits
x = Fix(x * d + 0.5) * isgn / d
my_round = x

End Function

Funktion Format()

dient zur Erzeugung formatierter Texte. Sie funktioniert ähnlich wie die Funktion TEXT() der ↑ Tabellen-Kalkulation.
Sie erwartet als 1. Argument eine Zahl und als 2. Argument einen Format-String. Für Kalkulation und Basic kann man die gleichen Format-Strings verwenden, mit Ausnahme der optionalen Tausender- und Dezimal-Trennzeichen:
Basic akzeptiert nur Tausender-Beistriche und Dezimal-Punkte. (Beide werden bei Rückgabe an ein Kalkulations-Programm umgewandelt).

Erzeugung formatierter Texte mit Basic:

x = 3141.592
s = Format(x,"0.0") ' ergibt 3141.6
s = Format(x,"0.000E+00") ' ergibt 3.142E+03

Zur Erzeugung komplizierter Texte ist Basic besser geeignet als die schwerfälligen Funktionen der Tabellen-Kalkulation.

Führende und folgende Nullen

Mit Funktion Format() kann man Strings mit führenden Nullen erzeugen. (z.B. zur Formulierung eines Datum & Zeit-Strings nach → ISO-8601)
Alternative (nur für ganze Zahlen): Man fügt links einen String aus mehreren Nullen an und schneidet daraus von rechts so viele Zeichen wie benötigt.
Im nächsten Absatz wird dazu eine komfortable Funktion vorgestellt:

Erzeugung 2stelliger ganzer Zahlen:

x = 2
s = Format(x,"00") ' erzeugt s="02"
t = String("0",2) & CStr(x)
t = Right(t,2) ' erzeugt t="02"

Die Funktion num_to_string() kombiniert mehrere Elemente:

Runden, Dezimal-Punkt, führende Nullen, folgende Nullen.

• Als 1.Argument wird die zu codierende Zahl x erwartet.
• Das optionale 2.Argument dig_pre gibt die Anzahl führender Ziffern an.
• Das optionale 3.Argument dig_post gibt die Anzahl der Nachkomma-Stellen an.

• Die Argumente dig_pre, dig_post werden auf definierte Werte gesetzt, wenn sie IsMissing() nicht angegeben wurden, und danach in jedem Fall auf ganze Zahlen gerundet.

• Ein negatives Vorzeichen stört die Formatierung: Es wird entfernt, in der Variablen isgn gespeichert und im letzten Schritt wieder hinzugefügt.

• Die Zahl wird auf dig_post Nachkomma-Stellen gerundet.

• Die gerundete Zahl wird mit Funktion CStr() in einen Text (String) umgewandelt. Ein Dezimal-Beistrich wird mit Replace() durch einen Dezimal-Punkt ersetzt.

• Mit Funktion InStr() wird die Position des Komma-Punkts bestimmt: Wenn der Punkt gefunden wird, dann wird der String in die Teile s1 (links vom Komma) und s2 (rechts vom Komma) getrennt.

• Wenn mehr führende Stellen dig_pre gewünscht werden, als in s1 enthalten sind, dann wird links mit Nullen ergänzt (s1 wird auf keinen Fall verkürzt). Wenn mehr folgende (Nachkomma)-Stellen dig_post gewünscht werden, als in s2 enthalten sind, dann wird rechts mit Nullen ergänzt.

• Der Ergebnis-Text wird aus s1 und s2 zusammengesetzt. Der Dezimal-Punkt wird nur dann eingefügt, wenn dig_post>0 gewünscht wurde.

• Zuletzt wird ein allfälliges negatives Vorzeichen wiederhergestellt.

Erzeugung von Strings mit führenden und folgenden Nullen sowie mit Dezimal-Punkt:

Function num_to_string(x As Double, _

Optional dig_pre As Variant, _
Optional dig_post As Variant) As String

Dim idc, isgn As Integer
Dim d, y As Double
Dim s1, s2, s As String

If (IsMissing(dig_pre)) Then dig_pre = 0
dig_pre = CInt(dig_pre)
If (IsMissing(dig_post)) Then dig_post = 0
dig_post = CInt(dig_post)

isgn = Sgn(x)
x = Abs(x)

d = 10 ^ dig_post
y = Int(x * d + 0.5) / d
s = Replace(CStr(y), ",", ".")

idc = InStr(s, ".")
If (idc > 0) Then

s1 = Left(s, idc - 1)
s2 = Right(s, Len(s) - idc)

Else

s1 = s

End If

If (dig_pre > Len(s1)) Then

s1 = Right(String(dig_pre, "0") & s1, dig_pre)

End If
If (dig_post > Len(s2)) Then

s2 = Left(s2 & String(dig_post, "0"), dig_post)

End If

s = s1
If (Len(s2) > 0) Then

s = s & "." & s2

End If

If (isgn < 0) Then s = "-" & s
num_to_string = s

End Function

Man kann die Funktion num_to_string() sowohl als Benutzer-definierte Funktion in einem Kalkulations-Programm einsetzen, als auch Basic-intern.
Die Tabelle zeigt einige Anwendungs-Beispiele. Dabei wird angenommen, dass sich in Zelle A1 die angegebene Zahl oder die Formel =10*PI() befindet.

Funktion	Ergebnis
=A1	31,41592
=num_to_string(A1)	31
=num_to_string(A1;5)	00031
=num_to_string(A1;0;2)	31.42
=num_to_string(A1;3;4)	031.4159
=num_to_string(-A1;3)	-031

Runden auf Stunden oder Minuten

Datum und Zeit wird in Kalkulations-Programmen und Basic gemeinsam als Gleitkomma-Zahl ( → Y1900-System) verwaltet.
Mit den beiden rechts gezeigten Funktionen kann man auf die nächst-liegende volle Stunden bzw. Minute runden.
Anwendung (links die Formeln, rechts die Zahlenwerte):

	A		B
1	=JETZT	2012-04-01 13:19:12	=A1	41000,555
2	=round_hours(A1)	2012-04-01 13:00:00	=A2	41000,54167
3	=round_minutes(A1)	2012-04-01 13:19:00	=A3	41000,55486

In den Spalten A und B sind die gleichen Zahlen-Werte enthalten. Spalte A ist jedoch mit dem Format "JJJJ-MM-TT hh:mm:ss" formatiert, Spalte B mit "Standard"

Basic-Funktionen zum Runden auf Stunden oder Minuten:

Function round_hours(y1900 As Double) As Double

round_hours = Int(y1900 * 24 + 0.5) / 24

End Function

Function round_minutes(y1900 As Double) As Double

round_minutes = Int(y1900 * 1440 + 0.5) / 1440

End Function

Runden mit Javascript

Ein Interpreter für diese Programmiersprache ist in jedem gängigen Browser-Programm enthalten.
Daher kann man Javascript einfach und ohne zusätzliche Programme verwenden.

Javascript-Programme sind im Quelltext einer Webseite enthalten und zusammen mit der Webseite portabel: Sie funktionieren ohne Änderung auf jedem Betriebssystem und mit jedem gängigen Browser.

Funktion round()

Diese Funktion aus dem Modul Math rundet auf die nächstliegende ganze Zahl. Die Rundung erfolgt (im Gegensatz zu den → Abschneide-Funktionen ceil(), floor() symmetrisch zum Nullpunkt.

Javascript-Funktion Math.round()

var x = 3.141592;
var y = Math.round(x); // ergibt y=3
var z = Math.round(-x); // ergibt z=-3

Alle weiteren hier vorgestellten Funktionen und Methoden geben einen Text (String) zurück, keine Zahl !

• Sie sind daher zur Ausgabe und zur weiteren Verarbeitung als Text gut geeignet, jedoch nicht zum Rechnen !

Man kann die erzeugten Strings mit der Funktion parseFloat() in Zahlen verwandeln und damit weitere Rechnungen ausführen.

Es zahlt sich nicht aus, zum Rechnen eigene Rundungs-Funktionen zu programmieren, weil die Rundung trotz des 'Umwegs' über den String erstaunlich schnell funktioniert.

Methode toFixed()

Diese Methode rundet auf die angegebene Zahl von Nachkomma-Stellen und gibt einen String zurück. Daher bleiben auch nachfolgende Nullen erhalten.
• Ohne Argument wird auf die nächst-liegende ganze Zahl gerundet.
• Das 2.Argument kann auch negativ sein: in diesem Fall wird auf ganze Zehner, Hunderter, Tausender... gerundet.

Javascript-Methode toFixed()

var x = 314.1592;
var y = x.toFixed(); // ergibt y="314"
y = x.toFixed(2); // ergibt y="314.16"
y = x.toFixed(1); // ergibt y="314.2"
y = x.toFixed(0); // ergibt y="314"
y = x.toFixed(-1); // ergibt y="310"
y = x.toFixed(-2); // ergibt y="300"
z = parseFloat(y); // ergibt z=300
z = z + 1; // ergibt z=301

Methode toExponential()

Diese Methode rundet auf die angegebene Zahl von Nachkomma-Stellen und gibt einen String im 'wissenschaftlichen' Exponential-Format zurück.
• Ohne Argument wird ein String mit maximaler Genauigkeit erzeugt.

Javascript-Methode toExponential()

var x = 31.41592;
var y = x.toExponential(); // ergibt y="3.141592e+1"
y = x.toExponential(0); // ergibt y="3e+1"
y = x.toExponential(3); // ergibt y="3.142e+1"

Die Funktion num_to_exp() verwendet die Methode toExpontial(). Der damit erzeugte String wird jedoch nachträglich verändert:
• Das Exponential-Zeichen e wird durch E ersetzt
• Der Exponent wird mit der angegebenen Anzahl von Ziffern formatiert.

Alle Argumente der Funktion sind optional:
• Das 1.Argument x bezeichnet die zu formatierende Zahl (Standard-Wert = 0)
• Das 2.Argument dig_mant bezeichnet die Anzahl der Nachkomma-Stellen in der Mantisse (Standard: alle)
• Das 3.Argument dig_exp bezeichnet die Anzahl der Stellen des Exponenten (Standard: 3)

• Zu Beginn werden entweder die optionalen Argumente oder deren Standard-Werte an die 3 Variablen x, dig_mant, dig_exp zugeweisen.

• Der String wird mit toExpontial() erzeugt und mit der → RegExp-Methode replace() das große E eingesetzt.

• Der String wird mit der RegExp-Methode match in einen Anfangsteil s und den Exponenten t getrennt. Der Exponent-String t wird in einer while-Schleife auf die gewünschte Länge dig_exp gebracht.

• Zuletzt wird der fertig formatierte String zurückgegeben.

Javascript-Funktion num_to_exp() erzeugt String in einem variablen Exponential-Format.

function num_to_exp() {

x=0;
if (num_to_exp.arguments.length > 0) {x=num_to_exp.arguments[0];}
dig_mant="";
if (num_to_exp.arguments.length > 1) {dig_mant=num_to_exp.arguments[1];}
dig_exp=3;
if (num_to_exp.arguments.length > 2) {dig_exp=num_to_exp.arguments[2];}
if(dig_exp>5) {dig_exp=5;}

var s=x.toExponential(dig_mant).replace(/e/,"E");

s.match(/([^E]*E.)(.*)/);
s=RegExp.$1;
var t=RegExp.$2;
while(dig_exp>t.length) {t="0"+t;}
s+=t;
return s;

}

Funktion	Ergebnis
x=31.41592	31.41592
=num_to_exp(x)	"3E+001"
=num_to_exp(x,2)	"3.14E+001"
=num_to_exp(x,3,2)	"3.142E+01"
=num_to_exp(x,4,1)	"3.1416E+1"

Methode toPrecision()

erzeugt ebenfalls einen String, formatiert jedoch nicht nach der absoluten Anzahl der Ziffern (wie die meisten anderen Rundungs-Funktionen), sondern nach der relativen Genauigkeit, angegeben als Anzahl signifikanter Dezimal-Ziffern.

• Das Argument bezeichnet die gesamte Anzahl der gewünschten Dezimal-Ziffern (vor + nach einem allfälligen Dezimal-Komma).
• Ohne Argument wird ein String mit maximaler Genauigkeit erzeugt.
• Das Argument n=0 ist nicht erlaubt.

Methode	Ergebnis
x=31.41592	31.41592
=x.toPrecision()	"31.41592"
=x.toPrecision(1)	"3e+1"
=x.toPrecision(2)	"31"
=x.toPrecision(3)	"31.4"
=x.toPrecision(4)	"31.42"

Numerisches Runden

Jede der ↑ 3 vorgestellten Rundungs-Funktionen gibt einen Text (String) zurück. Mit der Funktion parseFloat() kann man die Strings wieder in (gerundete) Zahlen umwandeln.

Beispiel: Runden einer Zahl auf 2 Stellen:

x = 31.41592;
r = parseFloat(x.toFixed(2));

// ergibt r = 31.42

Vorsicht, Falle !

Der Operator + wird in Javascript sowohl zur numerischen Addition als auch zur Verkettung von Strings verwendet. Wenn man versucht, so wie rechts gezeigt, die Zahl 1 zu addieren, dann wird die Ziffer "1" an den mit Methode toFixed() erzeugten String angehängt !

Beispiel: Keine (!) Fehlermeldung, aber mathematisch falsch !

x = 31.41592;
r = x.toFixed(2);
s = r + 1;

// ergibt s = "31.421"

Runden mit C/C++

Man braucht ein → Compiler-Programm zur Übersetzung von C/C++ Quelltext in ein 'Ausführbares Programm' (z.B. auf Windows *.exe).

Der Quelltext der Programmiersprache(n) → C/C++ ist portabel, die damit erzeugten Programme sind jedoch nicht portabel. Man muss für jedes Betriebssystem, teilweise auch für Betriebssystem-Varianten eigene Programme herstellen.

Runden zum Rechnen

Die Programmiersprache C/C++ bietet keine eigene Funktion zum arithmetischen Runden.

Die Standard-Bibliothek <math.h> enthält die beiden → Abschneide-Funktionen ceil(), floor() und die zum Potenzieren verwendete Funktion pow()

Die Funktion round_to_int() verwendet diese beiden Funktionen zum Runden auf die nächst-liegende ganze Zahl.
Die Funktion round_to_double() rundet auf die angegebene Zahl von Nachkomma-Stellen und gibt die gerundete Gleitkomma-Zahl zurück.

Das Beispiel enthält die beiden Funktionen und ein komplettes C-Programm zur Demonstration.

Grenze: Die Anwendung ist auf den Werte-Bereich des Variablen-Typs int beschränkt.

C/C++ Programm zum arithmetischen Runden:

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

int round_to_int(double);
double round_to_double(double,int);

int main() {

int iy;
double x,y;
x = 31.141592;
printf("x=%lf \n",x);
iy = round_to_int(x);
printf(", round(x)=%d \n",iy);
y = round_to_double(x);
printf(", round(x,2)=%lf \n",y);
return 0;

}

int round_to_int(double x) {

int i;
if(x>=0.0) {i=floor(x+0.5);}
else{i=ceil(x-0.5);}
return i;

}

double round_to_double(double x,int dig) {

int i;
double d,y;
d = pow(10.0,dig);
if(x>=0.0) {i=floor(x*d+0.5);}
else{i=ceil(x*d-0.5);}
y = ((double)i)/d;
return y;

}

Runden zur Ausgabe

Dazu verwendet man eine der Funktionen printf(), fprintf(), sprintf()
Die Funktionen erhalten zur Formatierung von Zahlen jeweils einen "Format-String" und die Liste der Variablen (in diesem Fall: nur 1 Variable).

Diese Standard-Funktione werden von den meisten modernen Programmiersprachen in ähnlicher Form verwendet.

♦ Details zu den Funktionen printf() und sprintf()

Formatierung mit Funktion printf(): Auswahl von Beispielen

Funktion	Ergebnis
iy=31;	31
printf("%d",iy);	"31"
printf("%03d",iy);	"031"
x=31.415927;	31.415927
printf("%f",x);	"31.1415927"
printf("%8.3f",x);	" 31.142"
printf("%08.3f",x);	"0031.142"
printf("%11.3E",x);	" 3.142E+001"

String zur weiteren Verarbeitung

Die → Funktion sprintf() erzeugt nach den jeweiligen Argumenten einen String und speichert ihn in der angegebenen String-Variablen (hier im Array s).

Das kann man verwenden, um einen (gerundeten und formatierten) String weiter zu verarbeiten. Die Arbeit mit Strings erfordert in C/C++ allerdings fortgeschrittene Kenntnisse.

Im Beispiel wird aus der Zahl x ein String erzeugt und im Array s gespeichert.
Das Exponential-Format hat für alle Zahlen die gleiche Text-Länge und lässt sich daher leicht in Mantisse (Array sm) und Exponent (Array se) trennen. Nach dem letzten Zeichen wird jeder String mit einem 0-Byte abgeschlossen.

Details zu den Funktionen strcpy() und strncpy() finden sie in der Dokumentation der Standard-Bibliothek <string.h>

♣ Mit Funktion sscanf() könnte man Zahlen-Strings wie diese wieder in Zahlen-Variable umwandeln (wird hier nicht gezeigt).

C/C++ Programm zur Verarbeitung eines formatierten Strings:

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

int main() {

double x;
char s[20],sm[20],se[5];
x = 31.4159265358979;

sprintf(s,"%11.3E",x);

printf("s = %s\n",s);
strcpy(sm,s);
sm[6] = 0;
printf("Mantisse = %s\n",sm);
strncpy(se,s+7,4);
se[4] = 0;
printf("Exponent = %s\n",se);
return 0;

}

Ausgabe:

s = 3.142E+001
Mantisse = 3.142
Exponent = +001

Runden mit Perl

Der Quelltext von → Perl-Programmen wird in einfachen Text-Dateien (Script-Programmen *.pl) gespeichert und von einem Perl-Interpreter-Programm Live ausgeführt.

Man braucht daher ein (kostenfreies) Interpreter-Programm zur Ausführung eines (portablen) Perl-Script-Programms.

Runden zum Rechnen

Die Programmiersprache → Perl bietet in der Basis-Version keine eigene Funktion zum arithmetischen Runden. Das (vollständige) Perl-Programm zeigt eine Möglichkeit für eine Funktion my_round()

• Das Mini-Programm demonstriert die Anwendung mit 1 Argument (rundet auf ganze Zahlen) und mit 2 Argumenten (rundet auf Nachkomma-Stellen).

• Die Funktion my_round() erwartet die zu rundende Zahl als 1. Argument.
Das 2.Argument ist optional und bezeichnet die Anzahl der gewünschten Nachkomma-Stellen.

• Die Argumente werden im → Array @_ an das sub übergeben. Mit scalar(@_) erhält man die Anzahl der Array-Elemente.

• Die Funktion verwendet die → Abschneide-Funktion int() zur Berechnung.

Perl-Programm mit Funktion zum Runden:

#!/usr/bin/perl

use strict;

my $x = 31.4159265358979;
print "x = $x\n";
my $iy = my_round($x);
print "iy = $iy\n";
my $y = my_round($x,3);
print "y = $y\n";

sub my_round {

my($x,$dig)=@_;
if(scalar(@_)<2) {$dig=0;}
my $d=10**$dig;
$x = $x*$d;
if($x>0) {$x+=0.5;}
else{$x-=0.5;}
return (int($x)/$d);

}

Ausgabe:

x = 31.4159265358979
iy = 31
y = 31.416

Runden zur Ausgabe

Dazu verwendet man eine der → Funktionen printf(), fprintf(), sprintf()
Die Funktionen erhalten zur Formatierung von Zahlen jeweils einen "Format-String" und die Liste der Variablen (in diesem Fall: nur 1 Variable).

Diese Standard-Funktionen werden von den meisten modernen Programmiersprachen in ähnlicher Form verwendet, z.B. auch von ↓ PHP.

♦ Details zur Funktion printf()

Formatierung mit Funktion printf(): Auswahl von Beispielen

Funktion	Ergebnis
$iy=31;	31
printf("%d",$iy);	"31"
printf("%03d",$iy);	"031"
$x=31.415927;	31.415927
printf("%f",$x);	"31.1415927"
printf("%8.3f",$x);	" 31.142"
printf("%08.3f",$x);	"0031.142"
printf("%11.3E",$x);	" 3.142E+001"

Programmiertes Ausgabe-Format

Man kann den Format-String - wie jeden anderen Text - auch 'programmieren'. So lässt sich z.B. die Anzahl der gewünschten Nachkomma-Stellen durch eine Variable (hier $dig) steuern.

Programmierung der Ausgabe mit 3 Nachkomma-Stellen:

my $dig = 3;
printf('%1.'.$dig.'f',$x);

String zur weiteren Verarbeitung

Die Programmiersprache → Perl ist besonders gut zur Verarbeitung von Text (Strings) geeignet. Insbesondere die Technik der → Regulären Ausdrücke ist besonders gut integriert.

• Im Beispiel wird aus der Zahl $x ein String $s erzeugt und mit einem Regulären Ausdruck in Mantisse $1 und Exponent $2 getrennt.

• Wenn man einen String wieder in eine Zahl umwandeln will, dann genügt es, die Zahl 0 zu addieren.

Perl Programm zur Verarbeitung eines formatierten Strings:

#!/usr/bin/perl
use strict;
my $x = 31.4159265358979;
my $s = sprintf("%11.3E",$x);
print "s = $s\n";
$s=~m/(.*?)E(.*)/;
print "Mantisse = ".($1+0)."\n";
print "Exponent = ".($2+0)."\n";

Ausgabe:

s = 3.142E+001
Mantisse = 3.142
Exponent = 1

Runden mit PHP
Der Quelltext von → PHP-Programmen wird in einfachen Text-Dateien (Script-Programmen *.php) gespeichert und von einem PHP-Interpreter-Programm Live ausgeführt.	Man braucht daher ein (kostenfreies) Interpreter-Programm zur Ausführung eines (portablen) PHP-Script-Programms. Mit PHP-Programmen werden meistens Webseiten hergestellt und von einem → Webserver-Programm verteilt.
Runden zum Rechnen Die Programmiersprache bietet in allen gängigen Versionen die Funktion round() zum Runden beliebiger Zahlen. Das 2. Argument ist optional und bezeichnet die Anzahl der gewünschten Nachkomma-Stellen.	Anwendung der PHP-Funktion round() <?php $x = 3.141592; $iy = round($x); // ergibt $iy=3 $y = round($x,2); // ergibt $y=3.142 ?>
Runden zur Ausgabe Dazu verwendet man eine der → Funktionen printf(), fprintf(), sprintf() Die Funktionen erhalten zur Formatierung von Zahlen jeweils einen "Format-String" und die Liste der Variablen (im Beispiel: nur je 1 Variable). Diese Standard-Funktionen werden von den meisten modernen Programmiersprachen in ähnlicher Form verwendet, z.B. auch von ↑ Perl • Das Beispiel zeigt die direkte Ausgabe mit printf() und die Rückgabe eines Strings ($s) mit sprintf(). Im String $s wird mit einem → Regulären Ausdruck das Standard Dezimal-Punkt durch den deutschen Dezimal-Beistrich ersetzt. ♦ Details und Beispiele zur Funktion printf()	Ausgabe gerundeter Zahlen mit Funktion printf() <?php $x = 3.141592; printf("x = %7.4f<br />\n",$x); $xs = sprintf("%7.4f",$x); $xs = preg_replace("/\./",",",$xs); print "x = $xs<br />\n"; ?> Ausgabe auf einer Webseite: x = 3.1416 x = 3,1416 (Beachten sie das unterschiedliche Dezimal-Trennzeichen).
Programmiertes Ausgabe-Format Man kann den Format-String - wie jeden anderen Text - auch 'programmieren'. So lässt sich z.B. die Anzahl der gewünschten Nachkomma-Stellen durch eine Variable (hier $dig) steuern.	Programmierung der Ausgabe mit 3 Nachkomma-Stellen: $dig = 3; printf('%1.'.$dig.'f',$x);
String zur weiteren Verarbeitung Zur Verarbeitung von Text (Strings) verwendet man am besten die Technik der → Regulären Ausdrücke. • Im Beispiel wird aus der Zahl $x ein String $s erzeugt und mit einem Regulären Ausdruck in Mantisse $1 und Exponent $2 getrennt. • Wenn man einen String wieder in eine Zahl umwandeln will, dann genügt es, die Zahl 0 zu addieren. Test	Perl Programm zur Verarbeitung eines formatierten Strings: <?php $x = 31.4159265358979; $s = sprintf("%11.3E",$x); print "s = $s<br />\n"; preg_match("/(.?)E(.)/",$s,$ra); print "Mantisse = ".($ra[1]+0)."<br />\n"; print "Exponent = ".($ra[2]+0)."<br />\n"; ?> Ausgabe auf einer Webseite: s = 3.142E+1 Mantisse = 3.142 Exponent = 1

Runden mit XML
Funktionen round() und round-half-to_even() sind in XPath und → XSL verfügbar.	Funktion round() arbeitet so wie in anderen Programmiersprachen. Funktion round-half-to-even() rundet auf die nächstliegende gerade ganze Zahl.

Algorithmen	Ausgewählte IT-Rezepte (Ganze Zahlen)
Runden	Runden auf Ganze Zahlen, Dezimalstellen, Rundungs-Fehler, ...
Kalkulation	Runden in Kalkulations-Programmen - RUNDEN(), TEXT()
Basic	Runden mit Basic (LibreOffice-Basic, Visual Basic (VBA) - Round(), Format()
Javascript	Runden mit Javascript - round(), toFixed(), toExponential(), toPrecision()
C/C++	Runden mit C/C++ - printf(), fprintf(), sprintf()
Perl	Runden mit Perl - printf(), fprintf(), sprintf()
PHP	Runden mit PHP - round(), printf(), fprintf(), sprintf()
XSL	Runden mit XPath und XSL
Verwandte Themen	Abschneiden von Gleitkomma-Zahlen (Funktionen ceil(), floor(), int() ) Rest (Modulo-Funktion), Funktion printf(C/C++, Perl, PHP)

Runden

Runden von Gleitkomma-Zahlen

Runden

Runden auf ganze Zahlen

Runden auf Nachkomma-Stellen

Runden auf <0 Stellen

Grenzen der Informatik

Fehler-Fortpflanzung

Rundung bei der Ausgabe

Runden mit Kalkulations-Programmen

Funktion RUNDEN()

Funktion ABRUNDEN()

Funktion AUFRUNDEN()

Runden auf End-Ziffern

Runden auf Stunden oder Minuten

Format

Funktion TEXT()

Funktion WECHSELN()

Runden mit Basic (LibreOffice-Basic, Visual Basic VBA)

Runden mit Basic

Funktion Format()

Führende und folgende Nullen

Runden auf Stunden oder Minuten

Runden mit Javascript

Funktion round()

Methode toFixed()

Methode toExponential()

Methode toPrecision()

Numerisches Runden

Vorsicht, Falle !

Runden mit C/C++

Runden zum Rechnen

Runden zur Ausgabe

String zur weiteren Verarbeitung

Runden mit Perl

Runden zum Rechnen

Runden zur Ausgabe

Programmiertes Ausgabe-Format

String zur weiteren Verarbeitung

Runden mit PHP

Runden zum Rechnen

Runden zur Ausgabe

Programmiertes Ausgabe-Format

String zur weiteren Verarbeitung

Runden mit XML

Funktionen round() und round-half-to_even()