Summary  
This chapter covers how to explicitly convert numeric values between integer, double, and complex types using built-in functions and explains the valid conversion hierarchy and rules (such as truncation of decimals and handling of imaginary parts).

General domain of usage  
Numerical computing

Zahlen können mithilfe von eingebauten Funktionen zwischen verschiedenen Typen konvertiert werden. Dies ermöglicht es, Werte bei Bedarf als Integer, Double oder komplexe Zahlen zu verwenden.

## Falsche Konvertierung
Das bloße Anhängen von `L` an eine bestehende Variable führt nicht zur Konvertierung:

## Korrekte Konvertierung
Stattdessen sollten Sie eine dieser Funktionen verwenden:
- `as.integer()`;
- `as.double()`;
- `as.complex()`.

as.integer(3.8)
as.double(5L)
as.complex(7)

Numerische Typen folgen einer Hierarchie, die definiert, wie Werte konvertiert werden können:
- `integer → double → complex`-Konvertierungen sind immer gültig;
- Die Umwandlung eines `double` in einen `integer` schneidet den Dezimalteil ab;
- Eine `complex`-Zahl kann nur konvertiert werden, wenn ihr Imaginärteil null ist.

# =====================================================================
# СКРЫТЫЕ ТЕСТЫ ДЛЯ 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 в двух вариантах:
#  1) в корне проекта:        ../../user_code.R  (относительно tests/testthat)
#  2) рядом с тестами:        user_code.R        (внутри tests/testthat)
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    = character(0),
  echo       = FALSE,
  print.eval = TRUE
)

# ---------- CASE 1 ----------
{
  out <- trimws(paste(res$logs, collapse = " "))
  ok  <- grepl("(^|[^0-9])9([^0-9]|$)", out)

  dynamic_test(
    ok,
    "Console output contains result of as.integer(9.85) (9)",
    sprintf("Expected console output to include '9' (result of as.integer(9.85)). Actual: %s", out)
  )
}

# ---------- CASE 2 ----------
{
  out <- trimws(paste(res$logs, collapse = " "))
  ok  <- grepl("(^|[^0-9])42([^0-9]|$)", out)

  dynamic_test(
    ok,
    "Console output contains result of as.double(42L) (42)",
    sprintf("Expected console output to include '42' (result of as.double(42L)). 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

Erwerben Sie ein fundiertes Verständnis von R, einer der am weitesten verbreiteten Sprachen für Datenanalyse. Erforschen Sie grundlegende Datentypen und eindimensionale Werte und vertiefen Sie sich anschließend in mehrdimensionale Strukturen wie Matrizen, Data Frames und Listen. Entwickeln Sie die Fähigkeiten, R effektiv in der statistischen Analyse und datenbasierten Entscheidungsfindung einzusetzen.

Erlernen Sie die Grundlagen der R-Syntax, wie Arithmetik, Variablen, Ausgabefunktionen und Kommentare. Vertiefen Sie Ihr Verständnis der rechnerischen Logik durch Übungen.

Untersuchung der Datentypen in R und deren Bedeutung für die Datenverarbeitung. Entwicklung von Fähigkeiten im Umgang mit Vektoren als grundlegende Strukturen zur Organisation und Analyse von Informationen.

Fähigkeit zur effektiven Verwaltung kategorialer Daten entwickeln. Erfahren, wie Rohdaten durch Strukturierung, Gruppierung und Interpretation in eindeutige Kategorien umgewandelt werden.

Verstehen, wie strukturierte zweidimensionale Daten dargestellt und bearbeitet werden. Sicherheit im Transformieren, Beschriften und Anwenden von Operationen auf Matrizen für analytische Aufgaben gewinnen.

Beherrschung der am häufigsten verwendeten Datenstruktur in R für tabellarische Informationen. Organisation, Transformation und Gewinnung von Erkenntnissen aus Datensätzen zur Unterstützung datenbasierter Entscheidungen.

Erfahren Sie, wie Listen über Vektoren hinausgehen, indem sie Elemente unterschiedlichen Typs und unterschiedlicher Länge speichern. Entwicklung der Fähigkeit, Listen zu erstellen, darauf zuzugreifen und sie zu modifizieren, um komplexe Datenstrukturen zu organisieren.

Typumwandlung

Falsche Konvertierung

Korrekte Konvertierung

Lösung

Awesome!

Typumwandlung

Falsche Konvertierung

Korrekte Konvertierung

Lösung