0Pricing
R Academy · Lekcja

Konwersja między typami liczbowymi

Bezpiecznie używaj as.integer(), as.double() i as.numeric().

Konwersja między typami liczbowymi to bezpłatna lekcja R Academy na CoddyKit. To lekcja 2 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej R Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs R Academy zawiera 4 lekcji w sumie.

Integer a Double w R

R ma dwa typy numeryczne: integer (liczby całkowite, tworzone za pomocą sufiksu L) oraz double (liczby zmiennoprzecinkowe, domyślny typ literałów numerycznych). Przez większość czasu R używa typu double, ale ich rozróżnianie ma znaczenie dla bezpieczeństwa typów i efektywnego wykorzystania pamięci.

x_dbl <- 5        # double by default
x_int <- 5L       # integer (L suffix)

cat('typeof(5):  ', typeof(x_dbl), '
')  # double
cat('typeof(5L): ', typeof(x_int), '
')  # integer
cat('5 == 5L:    ', x_dbl == x_int, '
') # TRUE (values equal)
cat('identical:  ', identical(x_dbl, x_int), '
')  # FALSE (types differ)

as.integer() — konwersja do typu integer

as.integer(x) konwertuje wartość do typu integer, obcinając (a nie zaokrąglając) część dziesiętną. Oznacza to, że 3.9 zmienia się w 3, a nie w 4. Sufiks L jest skróconym zapisem składniowym literałów całkowitoliczbowych.

cat('as.integer(3.7):  ', as.integer(3.7), '
')   # 3 (truncated, not 4)
cat('as.integer(3.2):  ', as.integer(3.2), '
')   # 3
cat('as.integer(-2.9): ', as.integer(-2.9), '
')  # -2 (toward zero)
cat('as.integer(10.9): ', as.integer(10.9), '
')  # 10

# Compare with round
cat('round(3.7):        ', round(3.7), '
')       # 4

as.double() i as.numeric()

as.double(x) i as.numeric(x) są równoważne — obie funkcje konwertują wartość do typu double (zmiennoprzecinkowego). Należy ich używać do konwersji liczb całkowitych na liczby typu double, gdy potrzebna jest dokładność ułamkowa.

count <- 7L  # integer
cat('typeof(count):         ', typeof(count), '
')

dbl_count <- as.double(count)
cat('typeof(as.double(7L)): ', typeof(dbl_count), '
')  # double
cat('Value:                 ', dbl_count, '
')           # 7

# Division automatically promotes to double
cat('7L / 2L:              ', 7L / 2L, '
')            # 3.5 (double)
cat('typeof(7L / 2L):      ', typeof(7L / 2L), '
')    # double

Arytmetyka liczb całkowitych

W R arytmetyka liczb całkowitych zwraca liczby całkowite dla operatorów +, - i *, ale dla operatora / zawsze zwraca typ double. Może to być zaskakujące, jeśli oczekują Państwo, że dzielenie całkowitoliczbowe zachowa typ integer.

a <- 6L
b <- 3L

cat('6L + 3L =', a + b, '| typeof:', typeof(a + b), '
')  # 9 integer
cat('6L - 3L =', a - b, '| typeof:', typeof(a - b), '
')  # 3 integer
cat('6L * 3L =', a * b, '| typeof:', typeof(a * b), '
')  # 18 integer
cat('6L / 3L =', a / b, '| typeof:', typeof(a / b), '
')  # 2 DOUBLE!
cat('6L %/% 3L =', a %/% b, '| typeof:', typeof(a %/% b), '
') # 2 integer

Obcinanie a zaokrąglanie

To kluczowe rozróżnienie: as.integer() obcina (usuwa część dziesiętną), natomiast round() zaokrągla do najbliższej liczby całkowitej. Należy zawsze jasno określić, które zachowanie jest potrzebne.

values <- c(2.1, 2.5, 2.9, -2.1, -2.5, -2.9)

cat('Original:     ', values, '
')
cat('as.integer():  ', as.integer(values), '
')  # truncate toward 0
cat('round():       ', round(values), '
')       # banker rounding
cat('floor():       ', floor(values), '
')       # round down
cat('ceiling():     ', ceiling(values), '
')     # round up

Ryzyko przepełnienia typu integer

Liczby całkowite w R mają 32 bity i mogą przechowywać wartości do około ±2,1 miliarda. Przekroczenie tego zakresu powoduje powstanie NA i wyświetlenie ostrzeżenia. Typ double może przechowywać znacznie większe wartości (do około 1,8 × 10^308).

max_int <- .Machine$integer.max
cat('Max integer:', max_int, '
')  # 2147483647

# Overflow produces NA
cat('max_int + 1L:', max_int + 1L, '
')  # NA with warning

# Double handles it fine
cat('as.double(max_int) + 1:', as.double(max_int) + 1, '
')  # 2147483648

Sufiks L w wektorach

Wektory typu integer można tworzyć, dodając sufiks L do każdego elementu albo przekazując sekwencję przez as.integer(). Operator dwukropka : automatycznie tworzy liczby całkowite.

# Colon produces integers
seq_int <- 1:5
cat('1:5 typeof:', typeof(seq_int), '
')  # integer

# Explicit integer vector
vec_int <- c(10L, 20L, 30L, 40L)
cat('c(10L,...) typeof:', typeof(vec_int), '
')  # integer

# as.integer on a vector
vec_dbl <- c(1.1, 2.9, 3.5, 4.7)
cat('as.integer(c(1.1,...)):', as.integer(vec_dbl), '
')  # 1 2 3 4

Pamięć i wydajność

Liczby całkowite zajmują 4 bajty na element, a liczby typu double — 8 bajtów. W przypadku bardzo dużych wektorów liczb całkowitych użycie typu integer może zmniejszyć zużycie pamięci o połowę. Jednak działania arytmetyczne na mieszanych typach automatycznie promują wynik do typu double.

n <- 1000000L

vec_int <- 1:n          # integer: 4 bytes each
vec_dbl <- as.double(1:n)  # double: 8 bytes each

cat('Integer vector size:', object.size(vec_int), 'bytes
')
cat('Double vector size: ', object.size(vec_dbl), 'bytes
')
cat('Ratio:', as.numeric(object.size(vec_dbl)) / as.numeric(object.size(vec_int)), '
')

Sprawdzanie przechowywania typu integer za pomocą is.integer()

Jeśli trzeba konkretnie zweryfikować przechowywanie typu integer, należy zawsze używać is.integer(), a nie is.numeric(). Liczba bez sufiksu L jest typu double, nawet jeśli wygląda jak liczba całkowita.

a <- 5    # looks like integer, but it is double
b <- 5L   # true integer

cat('is.integer(5):  ', is.integer(a), '
')   # FALSE!
cat('is.integer(5L): ', is.integer(b), '
')   # TRUE
cat('is.numeric(5):  ', is.numeric(a), '
')   # TRUE
cat('is.numeric(5L): ', is.numeric(b), '
')   # TRUE
cat('class(5):       ', class(a), '
')        # numeric
cat('class(5L):      ', class(b), '
')        # integer

Przykład procesu konwersji

Praktyczny proces pracy: odczytać dane jako wartości typu double (domyślnie), wykonać obliczenia, a następnie jawnie przekonwertować wyniki do typu integer tam, gdzie wymagane są liczby całkowite (np. dla liczności, indeksów lub identyfikatorów).

# Simulated: reading counts as doubles (common from CSV)
counts_raw <- c(12.0, 8.0, 15.0, 3.0, 22.0)
cat('typeof raw:', typeof(counts_raw), '
')  # double

# Convert to integer for proper storage
counts_int <- as.integer(counts_raw)
cat('typeof converted:', typeof(counts_int), '
')  # integer
cat('Counts:', counts_int, '
')
cat('Total:', sum(counts_int), '
')

Podsumowanie konwersji numerycznych

Najważniejsze funkcje konwersji typów numerycznych:

  • as.integer(x) — obcina do liczby całkowitej (usuwa część dziesiętną, w kierunku zera)
  • as.double(x) / as.numeric(x) — konwertuje do typu double
  • round(x) — zaokrągla do najbliższej wartości (należy użyć dla wartości przypominających liczby całkowite)
  • floor(x) / ceiling(x) — zaokrągla w dół / w górę
  • Składnia 5L — literał całkowitoliczbowy (konwersja nie jest potrzebna)
  • 1:n — zawsze tworzy liczby całkowite
x <- 7.8
cat('as.integer(7.8):', as.integer(x), '
')  # 7 (truncate)
cat('round(7.8):     ', round(x), '
')       # 8
cat('floor(7.8):     ', floor(x), '
')       # 7
cat('ceiling(7.8):   ', ceiling(x), '
')     # 8

Szybkie sprawdzenie

Co zwraca w R wyrażenie as.integer(3.9)?

Podsumowanie: konwersja typów numerycznych

Świetnie! Najważniejsze wnioski z tej lekcji:

  • R ma dwa typy numeryczne: integer (sufiks L, 4 bajty) oraz double (domyślny, 8 bajtów)
  • as.integer(x) obcina w kierunku zera — nie zaokrągla
  • as.double() i as.numeric() są identyczne — konwertują do typu double
  • / zawsze zwraca typ double, nawet dla operandów typu integer
  • 1:n tworzy sekwencje liczb całkowitych, a literały numeryczne bez L są typu double
  • Przepełnienie typu integer następuje przy około 2,1 miliarda — dla bardzo dużych liczb całkowitych należy używać typu double
# Demonstrate truncation vs rounding
test_vals <- c(0.1, 0.5, 0.9, 1.5, 2.5, 3.7)
cat('Values:      ', test_vals, '
')
cat('as.integer(): ', as.integer(test_vals), '
')  # truncation
cat('round():      ', round(test_vals), '
')       # nearest (banker)

Często zadawane pytania

Czy lekcja „Konwersja między typami liczbowymi” jest bezpłatna?

Tak — pełny tekst „Konwersja między typami liczbowymi” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu R Academy, przejdź na CoddyKit PRO. Kurs R Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Konwersja między typami liczbowymi”?

Bezpiecznie używaj as.integer(), as.double() i as.numeric(). Ćwiczysz R Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć R Academy?

Nie wymagamy żadnego doświadczenia. R Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 2 z 4.

Ile czasu zajmuje lekcja „Konwersja między typami liczbowymi”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji R Academy?

Tak. Każda lekcja R Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

  1. Przegląd systemu typów R
  2. Konwersja między typami liczbowymi
  3. Konwersja typów logicznych i znakowych
  4. Pułapki konwersji typów i dobre praktyki
← Powrót do R Academy