round

Runden auf die nächste Dezimalzahl oder Ganzzahl

Syntax

Y = round(X)

Y = round(X,N)

Y = round(X,N,type)

Y = round(___,TieBreaker=direction)

Y = round(t)

Y = round(t,unit)

Beschreibung

Y = round(X) rundet jedes Element von X auf die nächste Ganzzahl. Wenn die Dezimalstelle in der Mitte liegt, d. h. wenn ein Element einen Nachkommateil von 0.5 (innerhalb des Rundungsfehlers) im Dezimalsystem hat, rundet die round-Funktion von null weg auf die nächste Ganzzahl mit größerem Betrag.

Y = round(X,N) rundet auf N Stellen:

• N > 0: Rundung auf N Stellen rechts vom Dezimalkomma

• N = 0: Rundung auf die nächste Ganzzahl

• N < 0: Rundung auf N Stellen links vom Dezimalkomma

Y = round(X,N,type) gibt die Art der Rundung an. Geben Sie "significant" an, um auf N signifikante Stellen (gezählt ab der äußersten linken Ziffer) zu runden. In diesem Fall muss N eine positive Ganzzahl sein.

Y = round(___,TieBreaker=direction) rundet in der Mitte liegende Dezimalstellen so, wie es in direction festgelegt ist. Sie können dieses Argument nach allen Kombinationen von Eingabeargumenten aus den vorherigen Syntaxen verwenden.

Y = round(t) rundet jedes Element des duration-Arrays t auf die nächste Anzahl von Sekunden.

Y = round(t,unit) rundet jedes Element von t auf die nächste Zahl der festgelegten Zeiteinheit.

Beispiele

Runden von Matrixelementen

Runden Sie die Elemente einer 2x2-Matrix auf die nächste Ganzzahl.

X = [2.11 3.5; -3.5 0.78];
Y = round(X)

Y = 2×2

     2     4
    -4     1

Runden auf eine bestimmte Anzahl von Dezimalstellen

Runden Sie pi auf 3 Dezimalstellen.

Y = round(pi,3)

Y = 
3.1420

Runden auf das nächste Vielfache von 100

Runden Sie die Zahl 863178137 auf das nächste Vielfache von 100.

round(863178137,-2)

ans = 
863178100

Runden von Elementen auf eine bestimmte Anzahl signifikanter Stellen

Runden Sie die Elemente eines Vektors so, dass 2 signifikante Stellen erhalten bleiben.

X = [1253 1.345 120.44]

X = 1×3
103 ×

    1.2530    0.0013    0.1204

Y = round(X,2,"significant")

Y = 1×3
103 ×

    1.3000    0.0013    0.1200

Steuern der Zahlendarstellung während des Rundens

Der Befehl format steuert, wie MATLAB® Zahlen in der Befehlszeile anzeigt. Wenn eine Zahl zusätzliche Stellen enthält, die im aktuellen Format nicht angezeigt werden können, rundet MATLAB die Zahl automatisch zu Anzeigezwecken. Diese Rundung kann zu unerwarteten Ergebnissen führen, wenn sie mit der round-Funktion kombiniert wird.

Angenommen, das folgende Ergebnis einer Subtraktionsoperation liegt vor, und es werden 5 Stellen anzeigt.

format short
x = 112.05 - 110

x = 
2.0500

Als Ergebnis wird 2.0500 angezeigt, was genau in der Mitte zu liegen scheint. Aufgrund des Gleitkomma-Arithmetikfehlers liegt die in der Mitte liegende Dezimalstelle mit einem Nachkommateil von 0.5 jedoch nicht innerhalb des Rundungsfehlers.

Basierend auf dem angezeigten Wert von x sollte die Rundung von x auf 1 Dezimalstelle 2.1 zurückgeben.

y = round(x,1)

y = 
2

Das Problem besteht darin, dass MATLAB x zu Anzeigezwecken auf 5 Stellen rundet. Die round-Funktion gibt die richtige Antwort zurück. Lassen Sie sich x zur Bestätigung der Antwort im Format format long anzeigen, wodurch x gerundet auf 15 Stellen angezeigt wird.

format long
x

x = 
   2.049999999999997

Zeigen Sie zum Vergleich die Rundungsergebnisse für eine in der Mitte liegende Dezimalstelle an, die innerhalb des Rundungsfehlers liegt, und für eine andere, die nicht innerhalb des Rundungsfehlers liegt.

x1 = 2.05

x1 = 
   2.050000000000000

y1 = round(x1,1)

y1 = 
   2.100000000000000

x2 = 2.05 - eps(2.05)

x2 = 
   2.049999999999999

y2 = round(x2,1)

y2 = 
     2

Festlegen der Rundungsrichtung bei in der Mitte liegenden Dezimalstellen

Erstellen Sie einen Vektor aus Dezimalzahlen, die in der Mitte liegende Dezimalstellen aufweisen, d. h. Dezimalzahlen mit einem Nachkommateil von 0.5 (innerhalb des Rundungsfehlers).

X = -2.5:1:2.5

X = 1×6

   -2.5000   -1.5000   -0.5000    0.5000    1.5000    2.5000

Runden Sie die in der Mitte liegenden Dezimalstellen auf die nächsten geraden und ungeraden Ganzzahlen.

Yeven = round(X,TieBreaker="even")

Yeven = 1×6

    -2    -2     0     0     2     2

Yodd = round(X,TieBreaker="odd")

Yodd = 1×6

    -3    -1    -1     1     1     3

Runden Sie die in der Mitte liegenden Dezimalstellen zur positiven und negativen Unendlichkeit.

Yplusinf = round(X,TieBreaker="plusinf")

Yplusinf = 1×6

    -2    -1     0     1     2     3

Yminusinf = round(X,TieBreaker="minusinf")

Yminusinf = 1×6

    -3    -2    -1     0     1     2

Runden Sie die in der Mitte liegenden Dezimalstellenweg von null und gegen null.

Yfromzero = round(X,TieBreaker="fromzero")

Yfromzero = 1×6

    -3    -2    -1     1     2     3

Ytozero = round(X,TieBreaker="tozero")

Ytozero = 1×6

    -2    -1     0     0     1     2

Runden von Dauerwerten

Runden Sie jeden Wert in einem Dauer-Array auf die nächstliegende Anzahl von Sekunden.

t = hours(8) + minutes(29:31) + seconds(1.3:0.5:2.3);
t.Format = "hh:mm:ss.SS"

t = 1×3 duration
   08:29:01.30   08:30:01.80   08:31:02.30

Y1 = round(t)

Y1 = 1×3 duration
   08:29:01.00   08:30:02.00   08:31:02.00

Runden Sie jeden Wert in t auf die nächstliegende Anzahl von Stunden.

Y2 = round(t,"hours")

Y2 = 1×3 duration
   08:00:00.00   09:00:00.00   09:00:00.00

Eingabeargumente

X — Input Array

Skalar | Vektor | Matrix | mehrdimensionales Array | Tabelle | Timetable

Eingabearray, angegeben als Skalar, Vektor, Matrix, mehrdimensionales Array, Tabelle oder Timetable. Wenn X komplex ist, verarbeitet round die Real- und Imaginärteile unabhängig voneinander.

X muss vom Typ single, double, table oder timetable sein, wenn Sie round mit mehr als einer Eingabe verwenden.

round konvertiert logische und char-Elemente von X in double-Werte.

Datentypen: single | double | int8 | int16 | int32 | int64 | uint8 | uint16 | uint32 | uint64 | char | logical | table | timetable
Unterstützung komplexer Zahlen: Ja

N — Anzahl der Stellen

Skalar-Ganzzahl

Anzahl der Stellen, angegeben als Skalar-Ganzzahl. Wenn Sie N angeben, rundet die round(X,N)-Funktion X auf das nächstliegende Vielfache von 10^—N.

Wenn Sie "significant" als Rundungstyp angeben, muss N eine positive Ganzzahl sein.

type — Rundungstyp

"decimals" (Standardeinstellung) | "significant"

Rundungstyp, angegeben als "decimals" oder "significant". Der Rundungstyp bestimmt, ob round die Stellen in Bezug auf das Dezimalkomma oder die Gesamtzahl der signifikanten Ziffern berücksichtigt. N muss eine positive Ganzzahl sein, wenn Sie "significant" angeben. In diesem Fall rundet die round-Funktion auf die nächste Zahl mit N signifikanten Stellen.

Der Standardwert ist "decimals", d. h. round(X,N,"decimals") ist äquivalent zu round(X,N).

Beispiel: round(3132,2,"significant") gibt 3100 zurück, die nächstgelegene Zahl zu 3132 mit 2 signifikanten Stellen.

Datentypen: char | string

direction — Rundungsrichtung bei in der Mitte liegenden Dezimalstellen

"fromzero" (Standardeinstellung) | "tozero" | "even" | "odd" | "plusinf" | "minusinf"

Rundungsrichtung bei in der Mitte liegenden Dezimalstellen, angegeben als einer dieser Werte:

• "fromzero" – weg von null auf die nächste Ganzzahl mit größerem Betrag runden

• "tozero" – gegen null auf die nächste Ganzzahl mit kleinerem Betrag runden

• "even" – auf die nächste gerade Ganzzahl runden

• "odd" – auf die nächste ungerade Ganzzahl runden

• "plusinf" – gegen positive Unendlichkeit auf die nächste ganze Zahl mit größerem Wert runden

• "minusinf" – gegen negative Unendlichkeit auf die nächste Ganzzahl mit kleinerem Wert runden

Gleichstände treten selten auf. Bei der Verwendung von round(X,N,TieBreaker=direction) kommt es nur dann zu einer in der Mitte liegenden Dezimalstelle, wenn X * 10^N innerhalb eines Rundungsfehlers von einem Punkt in der Mitte zwischen zwei aufeinanderfolgenden Ganzzahlen liegt, wenn also X * 10^N einen Nachkommateil von 0.5 (innerhalb des Rundungsfehlers) im Dezimalsystem hat.

Beispiel: round(2.015,2,TieBreaker="even")

t — Eingabedauer

duration-Array

Eingabedauer, angegeben als duration-Array.

unit — Zeiteinheit

"seconds" (Standardeinstellung) | "minutes" | "hours" | "days" | "years"

Zeiteinheit, angegeben als "seconds", "minutes", "hours", "days" oder "years". Eine Dauer von 1 Jahr ist exakt gleich 365,2425 24-Stunden-Tagen.

Datentypen: char | string

Tipps

• Sowohl format short als auch format long zeigen gerundete Zahlen an. Diese Rundung kann zu unerwarteten Ergebnissen führen, wenn sie mit der round-Funktion kombiniert wird.

• Verwenden Sie zu Anzeigezwecken sprintf, um die genaue Anzeige einer Zahl als Zeichenfolge zu steuern. Wenn Sie zum Beispiel genau 2 Dezimalstellen von pi (ohne nachgestellte Nullstellen) anzeigen möchten, verwenden Sie sprintf("%.2f",pi).

Erweiterte Fähigkeiten

Tall Arrays

Rechnen mit Arrays, die mehr Zeilen haben, als in den Speicher passen.

Die Funktion round bietet vollständige Unterstützung für Tall-Arrays. Weitere Informationen finden Sie unter Tall-Arrays.

C/C++ Codegenerierung

Generieren Sie C und C++ Code mit MATLAB® Coder™.

Hinweise zur Verwendung und Einschränkungen:

• Die Codegenerierung unterstützt nur die Syntax Y = round(X).

GPU-Codegenerierung

Generieren von CUDA® Code für NVIDIA® Grafikprozessoren mit dem GPU Coder™.

Hinweise zur Verwendung und Einschränkungen:

• Die Codegenerierung unterstützt nur die Syntax Y = round(X).

Thread-Based Environment

Führen Sie mithilfe von MATLAB® backgroundPool den Code im Hintergrund aus oder machen Sie den Code mit der Parallel Computing Toolbox™ ThreadPool schneller.

Die Funktion round bietet vollständige Unterstützung für Thread-basierte Umgebungen. Weitere Informationen finden Sie unter Run MATLAB Functions in Thread-Based Environment.

GPU-Arrays

Schnellere Codeausführung durch Ausführen auf einer Grafikkarte (GPU) mit der Parallel Computing Toolbox™.

Die Funktion round unterstützt GPU-Array-Eingaben mit folgenden Verwendungshinweisen und Einschränkungen:

• Diese Syntaxen werden nicht unterstützt:

  Y = round(X,N)

  Y = round(X,N,type)

  Y = round(___,TieBreaker=direction)

Weitere Informationen finden Sie unter Run MATLAB Functions on a GPU (Parallel Computing Toolbox).

Verteilte Arrays

Partitionieren von großen Arrays über den kombinierten Speicher Ihres Clusters mit Parallel Computing Toolbox™.

Die Funktion round bietet vollständige Unterstützung für verteilte Arrays. Weitere Informationen finden Sie unter Run MATLAB Functions with Distributed Arrays (Parallel Computing Toolbox).

Versionsverlauf

Eingeführt vor R2006a

R2023a: Direkte Durchführung von Berechnungen für Tabellen und Timetables

Die Funktion round kann die Berechnung mit allen Variablen in einer Tabelle oder einem Timetable ausführen, ohne für den Zugriff auf diese Variablen eine Indizierung zu benötigen. Alle Variablen müssen Datentypen aufweisen, die die Berechnung unterstützen. Weitere Informationen finden Sie unter Direct Calculations on Tables and Timetables.

R2022a: Steuern des Rundungsverhaltens bei in der Mitte liegenden Dezimalstellen

Legen Sie mithilfe des TieBreaker-Name-Wert-Arguments fest, wie in der Mitte liegende Dezimalstellen gerundet werden sollen. round(X,TieBreaker="tozero") rundet in der Mitte liegende Dezimalstellen beispielsweise gegen null.

R2022a: round liefert konsistente Ergebnisse bei in der Mitte liegenden Dezimalstellen

Ab R2022a rundet die round-Funktion in der Mitte liegende Dezimalstellen standardmäßig immer weg von null auf das nächste Vielfache von 10^—N mit größerem Betrag. Beispiel:

X = 1.015:5.015;
N = 2;
Y = round(1.015:5.015,2)

Y =
    1.0200    2.0200    3.0200    4.0200    5.0200

In früheren Versionen lieferte die round-Funktion standardmäßig manchmal inkonsistente Ergebnisse bei in der Mitte liegenden Dezimalstellen. Im vorherigen Beispiel wurden beispielsweise das zweite und dritte Element auf 2.01 bzw. 3.01 gegen null gerundet.

R2014b: Runden auf eine bestimmte Anzahl von Stellen

In R2014b wurden diese Syntaxen hinzugefügt, um auf eine beliebige Anzahl von Dezimalstellen oder signifikanten Stellen zu runden und um Dauerwerte zu runden:

Y = round(X,N)
Y = round(X,N,type)
Y = round(t)  
Y = round(t,unit)   

Ältere Versionen von MATLAB^® unterstützen nur diese Syntax, die auf die nächste Ganzzahl rundet:

Y = round(X) 

Siehe auch

ceil | fix | floor

Themen

• Integers
• Floating-Point Numbers