Zahlen in R: numeric, integer & Mathematikfunktionen

numeric und integer: R's zwei Zahlentypen

R speichert Zahlen auf zwei Arten. Numeric (als Fließkommazahl doppelter Genauigkeit gespeichert) ist der Standard - jede Zahl, die du tippst, ist ein Double, sofern du nichts anderes sagst. Integer ist ein eigener, exakter Ganzzahltyp, den du mit dem L-Suffix anforderst:

x <- 3.14
n <- 42L

cat(typeof(x), typeof(n), "\n")
cat(class(x), class(n), "\n")

In der Praxis musst du dich selten darum kümmern: R konvertiert stillschweigend zwischen beiden, und is.numeric() ist für beide TRUE (siehe Datentypen für das komplette Typsystem). Die eine Stelle, an der der Unterschied durchschlägt, ist die Division - / liefert immer ein Double, selbst zwischen zwei Integers:

cat(7L / 2L, "\n")
cat(typeof(7L / 2L), "\n")

Integers tauchen meist als Ergebnis von Zählfunktionen auf (length(), seq_len(), nrow()) und als Indexwerte. Wenn du Ganzzahldivision brauchst, hat R einen eigenen Operator dafür - weiter unten behandelt.

Die Rundungsfamilie

R bietet dir fünf Wege, eine Zahl zu stutzen, jeder mit eigener Bedeutung:

cat(round(3.14159, 2), "\n")
cat(floor(2.7), "\n")
cat(ceiling(2.1), "\n")
cat(trunc(-2.7), "\n")
cat(signif(123456, 2), "\n")

• round(x, digits) - auf eine Anzahl Nachkommastellen (Standard 0).
• floor(x) - abwärts zur nächsten ganzen Zahl, stets Richtung negativ unendlich.
• ceiling(x) - aufwärts, stets Richtung positiv unendlich.
• trunc(x) - schneidet die Nachkommastellen ab, stets Richtung null. Beachte den Unterschied bei negativen Zahlen: trunc(-2.7) ist -2, aber floor(-2.7) ist -3.
• signif(x, digits) - auf eine Anzahl signifikanter Stellen, nicht Nachkommastellen: signif(123456, 2) ist 120000.

Und eine berühmte Überraschung: round() verwendet bei exakten Hälften round half to even (kaufmännisch-symmetrisches Runden) gemäß IEEE-754-Standard:

cat(round(0.5), round(1.5), round(2.5), round(3.5), "\n")

Das gibt 0 2 2 4 aus - jede Hälfte rundet zur nächsten geraden Zahl. Das ist kein Bug; es verhindert eine systematische Aufwärtsverzerrung, wenn du viele gerundete Werte summierst. Braucht ein Bericht Schulrundung, füge einen winzigen Aufschlag hinzu oder formatiere stattdessen erst in der Darstellungsschicht.

Alltägliche Mathematikfunktionen

Die Grundlagen funktionieren genau so, wie man es erwartet:

cat(sqrt(16), "\n")
cat(abs(-7.5), "\n")
cat(2^10, "\n")
cat(round(exp(1), 6), "\n")

sqrt() ist die Quadratwurzel, abs() der Absolutbetrag, ^ die Potenzierung, und exp(x) ist e hoch x - also ist exp(1) die eulersche Zahl, etwa 2,718282.

Die eine Funktion, die Leute stolpern lässt, ist log(). In R ist log() der natürliche Logarithmus (Basis e), nicht Basis 10:

cat(log(100), "\n")
cat(log10(100), "\n")
cat(log2(8), "\n")
cat(log(8, base = 2), "\n")

Die erste Zeile gibt ungefähr 4.60517 aus - nicht die 2, die ein Basis-10-Leser erwartet. Greif zu log10() und log2(), wenn du diese Basen meinst, oder übergib base = explizit. (Diese Konvention ist in der Statistik Standard, wo der natürliche Logarithmus der Normalfall ist.)

Modulo %% und Ganzzahldivision %/%

Zwei Operatoren decken die Restarithmetik ab:

cat(17 %% 5, "\n")
cat(17 %/% 5, "\n")

%% ist der Modulo (Rest): 17 geteilt durch 5 ist 3 Rest 2. %/% ist die Ganzzahldivision: wie viele ganze 5er in 17 passen. Zusammen erfüllen sie x == (x %/% y) * y + (x %% y).

Der klassische Einsatz von %% ist das Prüfen der Teilbarkeit:

n <- 12
cat(n %% 2 == 0, "\n")
cat(n %% 5 == 0, "\n")

Eine Feinheit bei negativen Zahlen: R's %% übernimmt das Vorzeichen des Divisors (wie Python, anders als C):

cat(-7 %% 3, "\n")

Das ergibt 2, nicht -1 - R beantwortet "Was addiere ich zu einem Vielfachen von 3, um -7 zu erreichen?", was Ergebnisse bei positivem Divisor in 0..2 hält. Praktisch für zyklische Indizes; überraschend, wenn du von C oder Java kommst.

Sonderwerte: Inf, -Inf und NaN

R's Zahlen folgen IEEE 754, weshalb manche Operationen Sonderwerte statt Fehler erzeugen:

cat(1 / 0, "\n")
cat(-1 / 0, "\n")
cat(0 / 0, "\n")

1/0 ist Inf (unendlich), -1/0 ist -Inf, und 0/0 - eine wirklich undefinierte Größe - ist NaN, "not a number". Die Unterscheidung zählt: Inf ist eine Antwort ("größer als alles"), NaN das Fehlen einer solchen. Getestet wird mit eigenen Funktionen, denn == NaN funktioniert nie:

cat(is.infinite(1 / 0), "\n")
cat(is.nan(0 / 0), "\n")
cat(is.na(0 / 0), "\n")

Beachte die letzte Zeile: NaN zählt auch als NA, also fängt is.na() es ab - ein weiterer Grund, warum is.na() die Standardprüfung "Ist dieser Wert unbrauchbar?" ist (mehr dazu unter fehlende Werte).

R liest und schreibt außerdem wissenschaftliche Notation nativ - 2.5e3 ist 2500, und sehr kleine oder große Zahlen werden standardmäßig in E-Notation ausgegeben:

cat(2.5e3, "\n")
cat(1e-4, "\n")
cat(format(1e-4, scientific = FALSE), "\n")

Nutze format(x, scientific = FALSE) (oder die scipen-Option), wenn ein Bericht schlichte Dezimalzahlen braucht.

Die Fließkomma-Überraschung

Jede Sprache, die Dezimalzahlen binär speichert, teilt diese eine Eigenheit, und R ist keine Ausnahme:

cat(0.1 + 0.2 == 0.3, "\n")
print(0.1 + 0.2, digits = 17)

FALSE - denn 0.1 + 0.2 ist tatsächlich 0.30000000000000004. Weder 0.1 noch 0.2 hat eine exakte Binärdarstellung, und die winzigen Fehler summieren sich. R's Standardausgabe verbirgt das, indem sie 7 signifikante Stellen zeigt - deshalb wirkt das Problem unsichtbar, bis ein ==-Vergleich scheitert.

Die Regel: Vergleiche berechnete Dezimalzahlen nie mit ==. Nutze all.equal(), das innerhalb einer sinnvollen Toleranz vergleicht:

cat(isTRUE(all.equal(0.1 + 0.2, 0.3)), "\n")

Pack es in isTRUE(), denn all.equal() gibt bei Abweichungen eine Beschreibung des Unterschieds zurück (nicht FALSE). Für Ganzzahlarbeit, bei der Exaktheit zählt, sind Integers bis etwa 2,1 Milliarden exakt - ein weiterer Grund, warum zählender Code den Integer-Typ nutzt.

Was du mitnimmst

• Jede getippte Zahl ist ein Double; 42L erzeugt einen Integer, und / liefert unabhängig davon ein Double.
• round() rundet Hälften zur geraden Zahl; floor/ceiling/trunc/signif stutzen jeweils anders - wisse, welches du meinst.
• log() ist der natürliche Logarithmus; nutze log10(), log2() oder base = für andere Basen.
• %% liefert den Rest (Vorzeichen folgt dem Divisor), %/% den ganzzahligen Quotienten.
• 1/0 ist Inf, 0/0 ist NaN, und 0.1 + 0.2 != 0.3 - vergleiche Dezimalzahlen mit all.equal(), nie mit ==.

Als Nächstes: die andere Hälfte des Datenalltags - Zeichenketten und die Funktionen, die R zum Bauen, Formatieren und Durchsuchen bietet.