0Pricing
R Academy · Lekcja

Arytmetyka i operacje na macierzach

Wykonuj mnożenie element po elemencie i mnożenie macierzy, a także dodawanie i odejmowanie.

Arytmetyka i operacje na macierzach to bezpłatna lekcja R Academy na CoddyKit. To lekcja 3 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.

Operacje element po elemencie a operacje macierzowe

R rozróżnia operacje element po elemencie (z użyciem +, -, *, /) oraz właściwe operacje macierzowe (z użyciem %*%). Zrozumienie tej różnicy ma kluczowe znaczenie dla poprawnego stosowania algebry liniowej.

A <- matrix(c(1,2,3,4), nrow = 2)
B <- matrix(c(5,6,7,8), nrow = 2)
cat('A:
'); print(A)
cat('B:
'); print(B)

# Element-wise multiply
cat('A * B (element-wise):
'); print(A * B)
# Matrix multiply
cat('A %*% B (matrix mult):
'); print(A %*% B)

Dodawanie i odejmowanie element po elemencie

Operatory + i - zastosowane do dwóch macierzy o tych samych wymiarach dodają lub odejmują odpowiadające sobie elementy. Są to wyłącznie operacje wykonywane element po elemencie.

# Monthly revenue vs target (in thousands)
revenue <- matrix(c(120,135,110,98, 145,160,132,115),
                  nrow = 2, byrow = TRUE)
target  <- matrix(c(130,130,130,130, 150,150,150,150),
                  nrow = 2, byrow = TRUE)

deviation <- revenue - target
cat('Revenue vs Target deviation:
')
print(deviation)
cat('Above target?:
')
print(revenue >= target)

Dzielenie i mnożenie element po elemencie

Podobnie operatory * i / zastosowane do macierzy o jednakowym rozmiarze działają element po elemencie. Jest to przydatne do skalowania, normalizacji lub łączenia macierzy element po elemencie.

# Scale a matrix by another (element-wise)
prices <- matrix(c(10, 20, 15, 25), nrow = 2)
quantities <- matrix(c(5, 3, 8, 2), nrow = 2)

total_cost <- prices * quantities
cat('Total cost per item:
')
print(total_cost)

# Normalise to row maximum
max_prices <- matrix(rep(apply(prices, 1, max), 2), nrow = 2)
norm_prices <- prices / max_prices
cat('Normalised prices:
')
print(norm_prices)

Operacje skalarne na macierzach

Za pomocą standardowych operatorów arytmetycznych można zastosować operację ze skalarem (pojedynczą liczbą) do każdego elementu macierzy. Skalar jest powielany, aby dopasować go do wymiarów macierzy.

m <- matrix(c(10, 20, 30, 40, 50, 60), nrow = 2, ncol = 3)
cat('Original:
'); print(m)

cat('m + 5:
');  print(m + 5)
cat('m * 2:
');  print(m * 2)
cat('m / 10:
'); print(m / 10)
cat('m ^ 2:
');  print(m ^ 2)

Właściwe mnożenie macierzy %*%

A %*% B wykonuje mnożenie macierzy w algebrze liniowej. Aby operacja zadziałała, liczba kolumn macierzy A musi być równa liczbie wierszy macierzy B. Wynik ma wymiary (wiersze A) x (kolumny B).

# 2x3 times 3x2 = 2x2
A <- matrix(c(1,2,3, 4,5,6), nrow = 2, byrow = TRUE)
B <- matrix(c(7,8, 9,10, 11,12), nrow = 3, byrow = TRUE)
cat('A (2x3):
'); print(A)
cat('B (3x2):
'); print(B)
cat('A %*% B (2x2):
'); print(A %*% B)

rowSums() i colSums()

rowSums(m) oblicza sumę każdego wiersza, a colSums(m) oblicza sumę każdej kolumny. Obie funkcje zwracają nazwane wektory, jeśli macierz ma nazwy wymiarów.

sales <- matrix(
  c(120,135,110,98,  145,160,132,115,  88,95,102,78),
  nrow = 3, byrow = TRUE,
  dimnames = list(c('Q1','Q2','Q3'), c('Jan','Feb','Mar','Apr'))
)
cat('Sales matrix:
'); print(sales)
cat('Quarterly totals:', rowSums(sales), '
')
cat('Monthly totals: ', colSums(sales), '
')

rowMeans() i colMeans()

rowMeans(m) i colMeans(m) zwracają odpowiednio średnią każdego wiersza i każdej kolumny. Są szybsze niż zastosowanie mean() za pomocą apply() w tym typowym zadaniu.

exam_scores <- matrix(
  c(88,92,75,81, 79,85,90,73, 95,78,82,88),
  nrow = 3, byrow = TRUE,
  dimnames = list(c('Alice','Bob','Carol'), c('Math','Sci','Eng','Hist'))
)
cat('Student averages:
')
print(rowMeans(exam_scores))
cat('Subject averages:
')
print(colMeans(exam_scores))

Operacje porównania na macierzach

Operatory porównania (==, >, <= itd.) zastosowane do macierzy zwracają macierz logiczną o tych samych wymiarach. Następnie można użyć tej maski do wybierania elementów lub zliczania.

scores <- matrix(c(88,45,92,61,73,55,84,79), nrow = 2)
cat('Scores:
'); print(scores)

# Which elements pass?
passing_mask <- scores >= 60
cat('Passing mask:
'); print(passing_mask)
cat('Number passing:', sum(passing_mask), '
')
cat('Passing scores:', scores[passing_mask], '
')

apply() do niestandardowych operacji na wierszach i kolumnach

apply(m, MARGIN, FUN) stosuje funkcję do wierszy (MARGIN=1) lub kolumn (MARGIN=2). Należy użyć tej funkcji, gdy potrzebują Państwo niestandardowej agregacji wykraczającej poza rowSums/colMeans.

m <- matrix(c(3,1,4,1,5,9,2,6,5,3,5,8), nrow = 3)
cat('Matrix:
'); print(m)

# Max of each row
cat('Row max:  ', apply(m, 1, max), '
')
# Range of each column
cat('Col range:
')
print(apply(m, 2, range))
# Custom: count values > 4 per row
cat('Values > 4 per row:', apply(m, 1, function(x) sum(x > 4)), '
')

Rozgłaszanie wektora w poprzek wierszy

Gdy dodają Państwo wektor do macierzy lub mnożą go przez macierz, R powiela wektor — cyklicznie przechodzi przez jego elementy, aby dopasować go do długości macierzy. Powielanie odbywa się kolumna po kolumnie, co może prowadzić do nieoczekiwanych wyników, jeśli chcą Państwo wykonywać operacje wierszami.

m <- matrix(c(10,20,30, 40,50,60), nrow = 2)
cat('Matrix:
'); print(m)

# Add a 3-element vector: R recycles column-by-column
v <- c(1, 2, 3)
cat('m + c(1,2,3):
'); print(m + v)

# For row-wise scaling, use sweep()
row_weights <- c(0.5, 2.0)  # scale row 1 by 0.5, row 2 by 2
cat('Row-wise scaled:
'); print(sweep(m, 1, row_weights, '*'))

Podsumowanie operacji arytmetycznych

Najważniejsze funkcje do operacji na macierzach w języku R:

  • +, -, *, / — arytmetyka element po elemencie
  • %*% — mnożenie macierzy (algebra liniowa)
  • rowSums(), colSums() — sumy wierszy i kolumn
  • rowMeans(), colMeans() — średnie wierszy i kolumn
  • apply(m, 1, fn) / apply(m, 2, fn) — niestandardowa agregacja wierszy i kolumn
  • sweep() — operacje na wierszach lub kolumnach z użyciem wektora
m <- matrix(c(4,9,16,25), nrow = 2)
cat('Original:
'); print(m)
cat('sqrt (element-wise):
'); print(sqrt(m))
cat('rowSums:', rowSums(m), '
')
cat('colMeans:', colMeans(m), '
')

Szybkie sprawdzenie

Co oblicza A * B, gdy A i B są macierzami 2x2 w języku R?

Podsumowanie: arytmetyka macierzy

Świetna praca! Najważniejsze informacje z tej lekcji:

  • +, -, *, / zastosowane do macierzy działają element po elemencie
  • %*% wykonuje właściwe mnożenie macierzy (wiersze × kolumny)
  • rowSums(), colSums(), rowMeans(), colMeans() wykonują agregację wierszy lub kolumn
  • Operatory porównania zwracają macierz logiczną o tym samym kształcie
  • apply(m, 1, fn) stosuje funkcję wierszami, a apply(m, 2, fn) kolumnami
  • Użyj sweep() do wektoryzowanego skalowania wierszy lub kolumn
# Final: compute grade curve (add 5 to all scores, cap at 100)
raw <- matrix(c(88,55,92,73,60,45,78,95), nrow = 2)
curved <- pmin(raw + 5, 100)  # pmin applies min element-wise
cat('Raw:
');    print(raw)
cat('Curved:
'); print(curved)

Często zadawane pytania

Czy lekcja „Arytmetyka i operacje na macierzach” jest bezpłatna?

Tak — pełny tekst „Arytmetyka i operacje na macierzach” 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 „Arytmetyka i operacje na macierzach”?

Wykonuj mnożenie element po elemencie i mnożenie macierzy, a także dodawanie i odejmowanie. Ć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 3 z 4.

Ile czasu zajmuje lekcja „Arytmetyka i operacje na macierzach”?

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. Tworzenie macierzy za pomocą matrix()
  2. Indeksowanie i wybieranie podzbiorów macierzy
  3. Arytmetyka i operacje na macierzach
  4. Transponowanie i zmiana kształtu macierzy
← Powrót do R Academy