Summary  
This chapter covers performing element-wise arithmetic on matrices, using aggregate functions to compute overall summaries (like sum and mean), and applying row- and column-wise summary functions.

General domain of usage  
Data analysis

Les matrices dans R prennent en charge les opérations arithmétiques, aussi bien avec des nombres uniques qu'avec des fonctions intégrées qui résument leurs valeurs.

## Opérations scalaires
L'application d'une opération arithmétique avec un nombre unique affecte chaque élément de la matrice.

m <- matrix(1:9, nrow = 3, byrow = TRUE)

# Multiply every element by 3
m * 3

## Fonctions d'agrégation
Des fonctions comme `sum()` et `mean()` calculent les totaux ou les moyennes sur l'ensemble de la matrice.

m <- matrix(1:9, nrow = 3, byrow = TRUE)

# Overall mean of all elements
mean(m)
# Overall sum of all elements
sum(m)

## Fonctions de lignes et de colonnes
Il est également possible d'appliquer ces fonctions séparément aux lignes ou aux colonnes avec `rowSums()`, `rowMeans()`, `colSums()` et `colMeans()`.

m <- matrix(1:9, nrow = 3, byrow = TRUE)

# Column sums
colSums(m)
# Row means
rowMeans(m)

Ces fonctions facilitent l'analyse des données matricielles par dimension.

# =====================================================================
# СКРЫТЫЕ ТЕСТЫ ДЛЯ user_code.R
#
# КАК МЫ РАБОТАЕМ:
#  1) Один раз выполняем пользовательский файл в отдельном окружении
#     через run_user_code(...). Получаем:
#       - res$values$...  — переменные из окружения
#       - res$logs        — весь печатный вывод (включая результаты выражений)
#  2) Каждый кейс — отдельный dynamic_test(...), то есть отдельная строка
#     в отчёте, с «говорящим» названием (успех/ошибка).
# =====================================================================

library(testthat)
source(testthat::test_path("helper-run_user_code.R"), local = TRUE)

# Ищем user_code.R
candidates <- c(
  testthat::test_path("..", "..", "user_code.R"),
  testthat::test_path("user_code.R")
)

candidates_norm <- vapply(candidates, function(p) {
  tryCatch(normalizePath(p, winslash = "/", mustWork = FALSE), error = function(e) NA_character_)
}, character(1))

exists_flags <- file.exists(candidates_norm)
if (!any(exists_flags)) {
  stop(
    sprintf(
      "user_code.R not found.\nChecked paths:\n  - %s\nWorking dir: %s",
      paste(candidates, collapse = "\n  - "),
      getwd()
    )
  )
}

user_file <- candidates_norm[which(exists_flags)[1]]

# Выполняем user_code.R и перехватываем консольный вывод
res <- run_user_code(
  file       = user_file,
  capture    = c("m"),
  echo       = FALSE,
  print.eval = TRUE
)

# ---------- CASE 1 ----------
{
  ok <- !is.null(res$values$m) && is.matrix(res$values$m)

  dynamic_test(
    ok,
    "Matrix 'm' is declared and is a matrix",
    "Expected 'm' to exist and be a matrix."
  )
}

# ---------- CASE 2 ----------
{
  expected_m <- matrix(c(2,3,4,5,6,7,8,9), nrow = 2, byrow = TRUE)
  ok <- all(res$values$m == expected_m)

  dynamic_test(
    ok,
    "Matrix 'm' values are correct after operation m <- m/2 + 1",
    sprintf("Expected matrix: %s. Got: %s",
            paste(expected_m, collapse = " "),
            paste(res$values$m, collapse = " "))
  )
}

# ---------- CASE 3 ----------
{
  col_total <- colSums(res$values$m)
  expected_colsums <- c(8,10,12,14)
  ok <- identical(as.numeric(col_total), expected_colsums)

  dynamic_test(
    ok,
    "colSums(m) returns correct column totals (8, 10, 12, 14)",
    sprintf("Expected colSums = c(8,10,12,14). Got: %s",
            paste(col_total, collapse = " "))
  )
}

# ---------- CASE 4 ----------
{
  m_mean <- mean(res$values$m)
  ok <- identical(m_mean, 5.5)

  dynamic_test(
    ok,
    "mean(m) returns correct overall mean (5.5)",
    sprintf("Expected mean(m) = 5.5. Got: %s", m_mean)
  )
}

# ---------- CASE 5 ----------
{
  out <- trimws(paste(res$logs, collapse = " "))
  ok <- grepl("2", out) && grepl("3", out) && grepl("4", out) &&
        grepl("5", out) && grepl("6", out) && grepl("7", out) &&
        grepl("8", out) && grepl("9", out) &&
        grepl("10", out) && grepl("12", out) &&
        grepl("14", out) && grepl("5.5", out)

  dynamic_test(
    ok,
    "Console output contains all expected matrix values, column sums, and mean",
    sprintf("Expected output to include numbers 2–9, 8–14, and 5.5. Actual: %s", out)
  )
}


test_hidden.R

# =====================================================================
# ВСПОМОГАТЕЛЬНЫЕ ХЕЛПЕРЫ ДЛЯ ТЕСТОВ
#
# Файл называется helper-*.R: testthat автоматически подхватывает такие
# файлы перед выполнением любых тестов в каталоге tests/testthat.
# =====================================================================

# -----------------------------------------------------------------------------
# run_user_code(...)
#  - безопасно запускает user_code.R в отдельном окружении (env)
#  - перехватывает ВЕСЬ вывод (stdout): как результаты выражений, так и print()/cat()
#  - возвращает:
#       values  — список запрошенных переменных (по именам из аргумента capture)
#       logs    — вектор строк перехваченного вывода
#       env     — окружение, где выполнялся user_code (можно исследовать при необходимости)
#
# ПАРАМЕТРЫ:
#   file        — путь к user_code.R
#   capture     — character-вектор имён переменных, которые нужно извлечь после выполнения
#   inject      — список объектов/функций, которые нужно «подложить» в среду исполнения
#                 (можно использовать для моков/маскировки опасных функций: system, file.remove и т.д.)
#   echo        — печатать код при исполнении (обычно FALSE)
#   print.eval  — ПЕЧАТАТЬ РЕЗУЛЬТАТЫ ВЫРАЖЕНИЙ. Ключевая опция, чтобы строки вида
#                 `prices['Armchair']` попадали в stdout без явного print().
#
# БЕЗОПАСНОСТЬ:
#   - В базовом R нет полноценной «песочницы». Мы изолируем код в новом env,
#     но ОС-доступ не блокируется магически.
#   - Для задач онлайн-платформы можно частично «глушить» опасные вызовы через inject,
#     например:
#       inject = list(
#         system      = function(...) stop("system disabled"),
#         file.remove = function(...) stop("file.remove disabled")
#       )
# -----------------------------------------------------------------------------
run_user_code <- function(
  file = "user_code.R",
  capture = character(0),
  inject = list(),
  echo = FALSE,
  print.eval = TRUE
) {
  # Бросаем явную ошибку, если файла нет (проще диагностировать)
  stopifnot(file.exists(file))

  # Изолированное окружение: parent=baseenv() (без лишних пользовательских объектов сверху)
  env <- new.env(parent = baseenv())

  # Подмешиваем моки/данные в окружение (при необходимости)
  if (length(inject)) list2env(inject, envir = env)

  # ВАЖНО: перехватываем весь вывод выполнения файла.
  # source(..., local=env, echo, print.eval) исполняет код ВНУТРИ env.
  # print.eval=TRUE заставляет R печатать результаты выражений (как в консоли),
  # что позволяет проверять «голые» выражения без print().
  logs <- utils::capture.output(
    base::source(file, local = env, echo = echo, print.eval = print.eval)
  )

  # Собираем запрошенные значения переменных
  values <- setNames(vector("list", length(capture)), capture)
  for (nm in capture) {
    if (exists(nm, envir = env, inherits = FALSE)) {
      values[[nm]] <- get(nm, envir = env, inherits = FALSE)
    } else {
      values[[nm]] <- NULL
    }
  }

  list(values = values, logs = logs, env = env)
}

# -----------------------------------------------------------------------------
# dynamic_test(condition, success, failure)
#  - Создаёт ОДИН тест с «динамическим» названием.
#  - Если condition=TRUE → тест называется success.
#  - Если condition=FALSE → тест называется failure, и тест проваливается.
#  - Используем настоящую expectation (expect_true(TRUE)), чтобы репортёры всегда
#    печатали имя успеха (TAP, progress и т.д.).
# -----------------------------------------------------------------------------
dynamic_test <- function(condition, success, failure) {
  if (isTRUE(condition)) {
    testthat::test_that(success, {
      testthat::expect_true(TRUE)
    })
  } else {
    testthat::test_that(failure, {
      testthat::fail(failure)
    })
  }
}
# =====================================================================

helper-run_user_code.R

Acquérir une compréhension solide de R, l'un des langages les plus utilisés pour l'analyse de données. Explorer les types de données fondamentaux et les valeurs unidimensionnelles, puis progresser vers des structures multidimensionnelles, y compris les matrices, les trames de données et les listes. Développer les compétences nécessaires pour appliquer R efficacement dans l'analyse statistique et la prise de décision basée sur les données.

Apprenez les bases de la syntaxe R, telles que l'arithmétique, les variables, les fonctions d'affichage et les commentaires. Renforcez votre compréhension de la logique computationnelle grâce à des exercices.

Explorez les types de données en R et comprenez leur rôle dans la gestion des données. Développez des compétences dans la manipulation des vecteurs en tant que structures essentielles pour organiser et analyser l'information.

Développer la capacité à gérer efficacement les données catégorielles. Découvrir comment structurer, regrouper et interpréter les valeurs en convertissant des données brutes en catégories claires.

Comprendre comment représenter et manipuler des données structurées à deux dimensions. Développer la confiance dans la transformation, l'étiquetage et l'application d'opérations sur les matrices pour des tâches analytiques.

Maîtrisez la structure de données la plus utilisée dans R pour les informations tabulaires. Apprenez à organiser, transformer et extraire des informations à partir de jeux de données afin de soutenir des décisions basées sur les données.

Apprenez comment les listes vont au-delà des vecteurs en stockant des éléments de types et de longueurs différents. Développez la capacité à créer, accéder et modifier des listes pour organiser des structures de données complexes.

Opérations avec des matrices

Opérations scalaires

Exemple

Fonctions d'agrégation

Exemple

Fonctions de lignes et de colonnes

Exemple

Solution