Введение в язык R для трейдера

Установка R для Microsoft Windows

Открываем официальный сайт и щёлкаем мышкой ссылку Download R x.x.x for Windows (здесь x.x.x обозначает номер версии программы).
После скачивания запускаем на выполнение файл R-x.x.x-win.exe.
В появившемся диалоговом окне выбираем язык Русский.
Два раза нажимаем кнопку Далее.
Выбираем папку для установки (лучше всего оставить ту, что задана по умолчанию) и снова нажимаем кнопку Далее.
Галочками выбираем тип установки (можно оставить по умолчанию) и снова нажимаем кнопку Далее.
Указываем, что не хотим изменять настройки запуска, выделив опцию Нет (принять умолчания) и опять нажимаем кнопку Далее.
Указываем имя группы в системном меню Пуск (оставляем имя R) и снова нажимаем кнопку Далее.
Галочками указываем дополнительные опции (лучше оставить всё по умолчанию) и последний раз нажимаем кнопку Далее.
Появляется индикатор установки. После окончания процесса установки нажимаем кнопку Завершить.
Теперь можно запустить систему R щелчком мыши по значку на рабочем столе или выбрав одноимённый пункт в системном меню Пуск.

Установка RStudio для Microsoft Windows

В качестве интерактивной среды разработки на R удобно использовать специальную программу RStudio.

Скачиваем дистрибутив с официального сайта.
Запускаем на выполнение инсталлятор RStudio-0.98.1083.exe (цифры обозначают номер версии и могут быть другими).
Нажимаем кнопку Далее.
Выбираем папку для установки (лучше оставить ту, что указана по умолчанию) и нажимаем кнопку Далее.
Нажимаем кнопку Установить.
Нажимаем кнопку Готово.

После установки для запуска программы надо выполнить пункты главного меню Windows: Пуск ‣ Программы ‣ RStudio ‣ RStudio.

Установка R и RStudio на Debian/Ubuntu

См. Установка R на Ubuntu и Установка RStudio на Ubuntu.

Установка специализированных пакетов

Для расширения возможностей R используются дополнительные пакеты-расширения. Чтобы установить пакет, надо в консоли R выполнить команду:

install.packages("ИмяПакета")

Вторым параметром можно указать, чтобы автоматически были установлены все другие пакеты, которые требуются для установки данного пакета, например:

install.packages("xts", dependencies=TRUE)
install.packages("PerformanceAnalytics", dependencies=TRUE)

В оболочке RStudio можно использовать аналогичную команду или пункт главного меню Tools -> Install Packages.

Мы часто будем использовать следующие пакеты:

tseries для анализа временных рядов;
quantmod для скачивания биржевых данных;
TTR для работы с техническими индикаторами;
quantstrat для тестирования стратегий;
PerformanceAnalytics для анализа эффективности и рисков;
FinancialInstrument для хранения сведений о финансовых инструментах (тикер, цена тика, месяцы экспирации,... )

Некоторые пакеты отсутствуют в главном репозитории, поэтому для их установки требуется указать адрес, например:

install.packages("quantmod", repos = "http://R-Forge.R-project.org")
install.packages("TTR", repos = "http://R-Forge.R-project.org")
install.packages("FinancialInstrument", repos = "http://R-Forge.R-project.org")
install.packages("blotter", repos = "http://R-Forge.R-project.org")
install.packages("quantstrat", repos = "http://R-Forge.R-project.org")

Периодически надо проверять обновления установленных пакетов; для этого предназначен пункт меню RStudio Tools (Инструменты) ‣ Check for Package Updates (Проверить обновления пакетов).

Режим калькулятора

В консоли R после приглашения > можно записывать любые арифметические выражения, после нажатия клавиши Enter будет выведен результат, например:

> 2+4*(5-1)/2
[1] 10

В квадратных скобках показывается номер первого элемента, с которого начинается вывод в данной строке. Если ответ будет содержать много элементов и не поместится в одной строке, то каждая следующая строка будет начинаться с номера элемента, который оказался в этой строке на первом месте. Для примера выведем все числа от 1 до 60:

 > 1:60
[1]  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29
[30] 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58
[59] 59 60

(место переноса зависит от ширины экрана консоли).

Возведение в степень обозначается знаком ^; для извлечение квадратного корня используется функция sqrt():

> 2^3 + sqrt(16)   # Два в степени 3 (т.е. 8) плюс квадратный корень из 16 (т.е. 4).
[1] 12

Длинные выражения можно разрывать, нажав клавишу Enter после очередного знака операции; тогда приглашение системы изменится с > на + и со следующей строки можно будет вводить продолжение. Аналогично интерпретатор команд поступит, если не найдёт в конце строки закрывающую скобку:

> 2+5-
+ 3
[1] 4

> 2*cos(pi
+ )
[1] -2

Если знак продолжения появился по ошибке (например, из-за отсутствия скобки), то прервать данный режим можно нажатием клавиши Escape.

Нажатие на клавиатуре клавиши стрелка вверх вызывает предыдущую выполненную команду; многократное нажатие стрелки позволяет перебирать команды из более глубокой истории. Кроме того, вся история выполненных команд доступна для просмотра и повторного выполнения в окне History (в RStudio оно вызывается нажатием Ctrl+4 или выполнением команды меню View -> Show History); для повторного вызова нужной команды достаточно выполнить двойной щелчок мыши по соответствующей строке в окне истории (или нажать Enter).

С помощью функции print() можно вывести число с заданной точностью, задав параметр digits (количество значащих цифр):

> pi
[1] 3.141593
> print(pi, digits=22)
[1] 3.141592653589793115998

Присваивание значений

Чтобы присвоить значение переменной, можно использовать как обычный для таких случаев знак =, так и стрелку (два символа <- или ->), например:

a = 5
b <- 2
3 -> с

Также имеется функция assign (присвоить), первый параметр которой (переменная) записывается в кавычках, а второй параметр — это присваиваемое значение:

assign("a", 5)

Обычно каждый оператор пишется с новой строки, но при желании разрешается записывать операторы в одной строке, разделяя их точкой с запятой:

x = 1; y <- x

В именах заглавные и строчные буквы различаются, т.е. например, Trend и trend — это разные переменные.

Имена должны начинаться с буквы и могут состоять из букв и цифр; специальные знаки в именах не разрешены, но можно использовать точку в любом месте, в том числе в качестве первого символа имени (что может оказаться неожиданным для тех, кто знаком с другими языками программирования).

После набора на клавиатуре первых символов имени переменной (уже использованной ранее) удобно нажать клавишу Tab, в результате оставшиеся символы будут дописаны автоматически. Если вариантов для автодополнения несколько, то будет предложен список для выбора.

В RStudio значения всех переменных показывается в окне Global Environment (по умолчанию оно расположено вверху справа; если его не видно, то надо нажать комбинацию клавиш Ctrl+8 или выполнить пункт меню View -> Show Environment).

Если какая-то переменная больше не нужна, то для её удаления из памяти используется функция rm():

> x <- 5
> x
[1] 5
> rm(x)
> x
Error: object 'x' not found

Специальные значения

Кроме чисел, символов и строк в R имеются следующие специальные значения:

NA — Not Available (не доступно) — пропущенное значение;
NULL — пустой объект (пустое множество);
Inf — Infinity (бесконечность);
NaN — Not a Number (не число).

Примеры:

> 1 / 0   # Деление положительного числа на нуль даёт бесконечность.
[1] Inf

> log(0)  # Логарифм нуля равен минус бесконечности.
[1] -Inf

> 10 / Inf  # Положительное число, делённое на бесконечность, даёт 0.
[1] 0

> atan(-Inf)  # Арктангенс от минус бесконечности (результат в радианах).
[1] -1.570796

> as.numeric("A")  # Попытались преобразовать символ в число.
[1] NA

> x <- 5;  names(x)  # Попытались узнать имя объекта.
[1] NULL

> sqrt(-1)  # Квадратный корень из минус единицы.
[1] NaN

> 0 / 0     # Деление нуля на нуль тоже даёт "не число".
[1] NaN

> x <- 0 / 0;  x + 5   # Выражение, в котором есть хотя бы одно "не число", в результате тоже даёт "не число".
[1] NaN

Векторы

Вектор (упорядоченный набор значений) создаётся с помощью функции c() (от англ. concatenate – сцепить, объединить):

> a <- c(1, 2, 5, 8, 15, 20:23)
> a
[1]  1  2  5  8  15  20  21  22  23

Кроме чисел, элементами могут быть также символы, строки или логические значения:

> b <- c(3, "a", "hello", T, F)
> b
[1] "3"  "a"  "hello"  "TRUE"  "FALSE"

Элементы нумеруются, начиная с 1. Доступ к отдельному элементу можно получить, записывая его номер в квадратных скобках:

> b[2]
[1] "a"

Количество элементов в списке возвращает функция length():

> v <- c(1, 2, 5);  length(v)
[1] 3

Все функции в R могут принимать векторные аргументы, например:

> x <- c(1:4);  y <- sqrt(x);  y
[1] 1.000000  1.414214  1.732051  2.000000

Операции сравнения вектора с числом, символом или строкой возвращают вектор логических значений:

> v <- c(1, 2, 5);  v == 5              # Сравнение на равенство с числом.
[1] FALSE  FALSE   TRUE

> w <- c(90, "A", 84, "B");  w >= "B"   # Сравнение на больше или равно с символом.
[1] FALSE  FALSE  FALSE   TRUE

Можно сравнивать векторы поэлементно:

> x <- c(1, 3, 8);  y <- c(2, 1, 8);  x == y
[1] FALSE  FALSE   TRUE

Аналогично работают и арифметические операции:

x <- c(1, 2, 5);  y <- c(2, 6, 4);  x + y
[1] 3 8 9

Если длина одного вектора кратна длине другого, то элементы более короткого вектора будут использоваться, как будто они образуют замкнутую цепь: по достижении конца вектора мы снова перейдём в его начало:

> x <- c(1, 5);  y <- c(2, 1, 4, 3);  x + y
[1] 3 6 5 8

При сложении векторов, длины которых не кратны друг другу, используется тот же алгоритм, но будет выдано предупреждение:

> x <- c(1, 2);  y <- c(2, 6, 4);  x + y
[1] 3 8 5
Warning message:
In x + y : longer object length is not a multiple of shorter object length

Аналогично работают с векторами и другие арифметические операции, а также операции сравнения.

С помощью функции seq() можно создать вектор, задавая начальное значение from, конечное значение to, шаг by или число элементов length. Например:

> u <- seq(from = -2, to = 3, by = 0.5)
> u
[1] -2.0 -1.5 -1.0 -0.5  0.0  0.5  1.0  1.5  2.0  2.5  3.0

или (с тем же результатом):

> v <- seq(-2, 3, length = 11)

Последние два примера иллюстрируют два способа задания значений параметров функций: по их позиции и по имени. В первом примере все три параметра были переданы функции seq по имени (поэтому их порядок значения не имел). Во втором вызове функции seq первые два параметра (-2 и 3) заданы своей позицией в списке параметров, а третий параметр (length) – по имени.

Имеется множество функций для работы с векторами:

> x <- c(1, 2, 5, NA, 4)
> mean(x)  # Функция для вычисления среднего значения.
[1] NA

> mean(x, na.rm = TRUE)   # Среднее значение без учёта NA.
[1] 3

> sum(x, na.rm = T)       # Сумма элементов без учёта NA.
[1] 12

Для вызова списка возможных параметров функций удобно использовать клавишу Tab.

В помощью функции rep() можно сгенерировать вектор, в котором несколько раз повторяется заданная последовательность, например:

> rep(1:3, 4)
[1] 1 2 3 1 2 3 1 2 3 1 2 3

Второй параметр может быть тоже вектором (той же длины, что и первый параметр), тогда каждый элемент первого вектора будет повторён столько раз, сколько задано в соответствующем элементе второго вектора:

> rep(1:3, c(1, 3, 2))
[1] 1 2 2 2 3 3

Списки

Список отличаются от вектора тем, что элементами списка могут быть не только атомарные значения, но также другие списки, т.е. этот тип данных является рекурсивным.

Список создаётся с помощью функции list():

> y <- list(1:3, "str1", T, list("a", "b", F))
> y
[[1]]
[1] 1 2 3

[[2]]
[1] "str1"

[[3]]
[1] TRUE

[[4]]
[[4]][[1]]
[1] "a"

[[4]][[2]]
[1] "b"

[[4]][[3]]
[1] FALSE

Обращение к элементам списка производится с помощью квадратных скобок, но если использовать одиночные скобки, то результатом будет тоже список, а если двойные скобки — то сам элемент:

> y[2]
[[1]]
[1] "str1"

> y[[2]]
[1] "str1"

Работа с датами

Даты хранятся в памяти компьютера в виде числа дней, прошедших с 1 января 1970 года (более ранние даты представляются отрицательными числами).

Для преобразования строки в дату используется функция as.date():

> as.Date('2015-05-13')
[1] "2015-05-13"

Можно задать, в каком формате указана дата (на каком месте в строке стоят год, месяц и день и какой используется разделитель):

> as.Date('3/15/2014', format='%m/%d/%Y')   #  т.е. месяц / день / год.
[1] "2014-03-15"

Функция as.numeric() возвращает внутреннее представление даты, т.е. целое число дней:

> a <- as.Date('5/1/1970', format='%d/%m/%Y');  as.numeric(a)
[1] 4

> b <- as.Date('1969-12-31');  as.numeric(b)
[1] -1

Кроме того, имеется два вида представления даты и времени, в которых учитывается часовой пояс (time zone), а время хранится с точностью до секунды. В формате POSIXlt хранится список элементов: число секунд, минут, часов, дней, месяцев и лет, прошедших с начала 1 января 1970 года. А в формате POSIXct хранится число секунд, прошедших с того же самого момента:

> as.POSIXct("2013-08-19 15:48:05", tz="Europe/Moscow")
[1] "2013-08-19 15:48:05 MSK"

> as.POSIXct("2013-08-19 15:48:05", tz="Europe/London")
[1] "2013-08-19 15:48:05 BST"

Список обозначений часовых поясов можно найти в Интернет по адресу http://unicode.org/repos/cldr/trunk/common/supplemental/windowsZones.xml.

Можно использовать произвольный формат представления даты и времени в виде строки, например:

as.POSIXct("19.08.2013 15:48:05", format="%d.%m.%Y %H:%M:%S", tz="UTC")
[1] "2013-08-19 15:48:05 UTC"

Если часовой пояс не указан, то используются системные настройки (см. ниже).

Можно создать объект, представляющий дату, из отдельных чисел, обозначающих год, номер месяца, день, час, минуту и секунду:

> ISOdate(2014, 11, 28, 19, 11, 37, tz="GMT")
[1] "2014-11-28 19:11:37 GMT"

Если часовой пояс не указан, то по умолчанию используется GMT.

Текущую дату и время возвращает функция Sys.time():

> Sys.time()
[1] "2015-05-09 17:28:31 MSK"

Дату и время можно преобразовать в строку, задав нужный формат:

> format(Sys.time(), "%A, %B %d, %Y - %H:%M:%S (%Z)")
[1] "суббота, Май 09, 2015 - 17:28:31 (MSK)"

Можно создать последовательность дат (результат зависит от текущего часового пояса, заданного в операционной системе):

> seq(as.POSIXct("2014-01-01"), by = "month", length = 4)
[1] "2014-01-01 MSK"  "2014-02-01 MSK"  "2014-03-01 MSK"  "2014-04-01 MSK"

или (результат не зависит от текущего часового пояса):

> seq(ISOdate(2011, 1, 1), ISOdate(2014, 1, 1), "years")
[1] "2011-01-01 12:00:00 GMT" "2012-01-01 12:00:00 GMT" "2013-01-01 12:00:00 GMT" "2014-01-01 12:00:00 GMT"

Текущий часовой пояс, используемый системой, хранится в переменной окружения TZ, его можно изменить с помощью функции Sys.setenv():

> Sys.timezone()
[1] "Europe/Moscow"

> Sys.setenv(TZ='UTC')
> Sys.timezone()
[1] "UTC"

Атрибуты

Всем объектам в R могут быть приписаны атрибуты — пары имя, значение. Пример:

> a <- 1:5
> attr(a, "MyName") = "MyVector"
> attr(a, "Value1") = 10
> a
[1] 1 2 3 4 5
attr(,"MyName")
[1] "MyVector"
attr(,"Value1")
[1] 10

Имена и значения всех атрибутов можно узнать с помощью функции attributes():

> attributes(a)
$MyName
[1] "MyVector"

$Value1
[1] 10

> attributes(a[1])
NULL

При создании вектора можно указать имя каждого его элемента:

> x <- c(a = 1, b = 2, c = 3)
> x
a b c
1 2 3

Можно задать имена потом (с тем же результатом):

> x <- 1:3;  names(x) <- c("a", "b", "c")

или:

> x <- setNames(1:3, c("a", "b", "c"))

При выборке имена сохраняются:

> x[2]
b
2

Матрицы

Матрица (двумерный массив) создаётся с помощью функции matrix. По умолчанию элементы в матрице располагаются по столбцам:

> b <- matrix(1:12, 3, 4)
> b
      [,1] [,2] [,3] [,4]
[1,]    1    4    7   10
[2,]    2    5    8   11
[3,]    3    6    9   12

но можно задать порядок по строкам:

> a <- matrix(data = 1:12, nrow = 3, ncol = 4, byrow = T)
> a
      [,1]  [,2]  [,3]  [,4]
[1,]    1     2     3     4
[2,]    5     6     7     8
[3,]    9    10    11    12

Элементы матриц нумеруются, начиная с 1; сначала записывается номер строки, затем номер столбца:

> a[2, 3];  b[1, 4]
[1] 7
[1] 10

Можно выделять блоки-подматрицы:

> b[1:2, 1:3]
      [,1] [,2] [,3]
[1,]    1    4    7
[2,]    2    5    8

Вектор можно превратить в матрицу, задав его новую размерность:

> x <- 1:6;  dim(x) <- c(2, 3);  x
     [,1]  [,2]  [,3]
[1,]    1     3     5
[2,]    2     4     6

Функция dim() возвращает размерность матрицы (число строк и столбцов):

> a <- matrix(1:6, 2, 3);  dim(a)
[1]  2  3

Матрицу можно создать из нескольких векторов, считая их или колонками, или строками матрицы:

> cbind(c(1, 2, 3), c(4, 5, 6))
      [,1] [,2]
[1,]    1    4
[2,]    2    5
[3,]    3    6
> rbind(c(1, 2, 3), c(4, 5, 6))
      [,1] [,2] [,3]
[1,]    1    2    3
[2,]    4    5    6

Все функции могут принимать матрицы в качестве параметров:

> x <- matrix(1:6, 2, 3);  y = x^2;
> y
     [,1]   [,2]   [,3]
[1,]   1      9     25
[2,]   4     16     36

Поэлементное умножение матрицы на вектор:

> a <- matrix(1:6, 2, 3);  a
     [,1] [,2] [,3]
[1,]    1    3    5
[2,]    2    4    6
> b <- c(2, 3, 1);  b
[1]  2  3  1
> a*b
     [,1] [,2] [,3]
[1,]    2    3   15
[2,]    6    8    6

(элементы матрицы просматриваются по столбцам и умножаются на соответствующий элемент вектора; когда достигнут конец вектора, мы опять переходим в его начало).

Матричное умножение (размерности должны быть согласованы):

> a %*% b
     [,1]
[1,]   16
[2,]   22

Транспонирование матрицы:

> t(a)
     [,1] [,2]
[1,]    1    2
[2,]    3    4
[3,]    5    6

Многомерные массивы

Многомерные массивы создаются с помощью функции array():

> a <- array(c(1:24), dim = c(2, 4, 3));  a
, , 1

     [,1] [,2] [,3] [,4]
[1,]    1    3    5    7
[2,]    2    4    6    8

, , 2

     [,1] [,2] [,3] [,4]
[1,]    9   11   13   15
[2,]   10   12   14   16

, , 3

     [,1] [,2] [,3] [,4]
[1,]   17   19   21   23
[2,]   18   20   22   24

Можно преобразовать вектор в многомерный массив (с тем же результатом):

> x <- c(1:24);  dim(x) <- c(2, 4, 3);  x

Фреймы

Фрейм данных (Data Frame) — это двумерный массив (таблица) с именованными столбцами. Фрейм создаётся с помощью функции data.frame():

> n <- c(2, 3, 5);
> s <- c("abc", "bca", "cbdac");
> b <- c(TRUE, FALSE, TRUE)
> df <- data.frame(n, s, b)
> df
   n      s      b
1  2    abc   TRUE
2  3    bca  FALSE
3  5  cbdac   TRUE

C помощью функции names() можно узнать или изменить имена столбцов:

> names(df) <- c("N", "String", "Flag"); df
    N  String   Flag
1   2     abc   TRUE
2   3     bca  FALSE
3   5   cbdac   TRUE
> names(df)
[1]  "N"   "String"  "Flag"

Можно указать заголовки столбцов сразу при создании фрейма из векторов, результат будет тем же самым:

> df <- data.frame(N=n, String=s, Flag=b)

Строковое представление фрейма:

> str(df)
'data.frame':       3 obs. of  3 variables:
 $ N     : num  2 3 5
 $ String: Factor w/ 3 levels "abc","bca","cbdac": 1 2 3
 $ Flag  : logi  TRUE FALSE TRUE

Функция nrow() возвращает число строк, функция ncol() — число столбцов фрейма данных.

Для обращения к элементу фрейма надо в квадратных скобках указать номер строки и номер столбца (напоминаем, что нумерация начинается с 1):

> df[2, 3]
[1] FALSE

Можно выделить из фрейма заданный столбец по номеру:

> df[2]
   String
1     abc
2     bca
3   cbdac

или:

> df[[3]]
[1]  TRUE  FALSE  TRUE

Выделение столбца по имени:

> df["Flag"]
    Flag
1   TRUE
2  FALSE
3   TRUE

или с помощью символа $:

> df$Flag
[1]  TRUE FALSE  TRUE

Выделение нескольких столбцов:

> df[,2:3]
  String   Flag
1    abc   TRUE
2    bca  FALSE
3  cbdac   TRUE

Чтобы выбрать конкретную строку по номеру, надо просто не указывать номер столбца, обязательно оставив запятую:

> df[2,]
   N  String   Flag
2  3     bca  FALSE

Выборка строк по условию:

> df[df$Flag==TRUE, ]
   N  String  Flag
1  2     abc  TRUE
3  5   cbdac  TRUE

Здесь выражение в квадратных скобках задаёт логический вектор:

> df$Flag==TRUE
[1]  TRUE FALSE  TRUE

элементы которого, равные истине, используются для выборки строк таблицы. Кроме сравнения на равенство ==, можно использовать любые другие (>, <, >=, <=, !=), а также знаки логических операций И, ИЛИ, НЕ (&, |, !).

После ввода символа $ удобно нажимать уже знакомую нам клавишу Tab, чтобы вывести список имён столбцов фрейма.

Текущий каталог

R предназначен для обработки данных, а данные надо где-то хранить. Проще всего хранить данные в отдельных файлах. Эти файлы по умолчанию размещаются в рабочем каталоге. Чтобы установить рабочий каталог, используют функцию setwd(), например, в Microsoft Windows:

setwd("c:/work/R")

в Linux/Ubuntu:

setwd("~/work/R")

Функция getwd() (без параметров) возвращает текущий каталог в виде строки.

Хранение данных в текстовых файлах

Для записи данных в текстовый файл можно использовать функцию write.table(). Например, запишем матрицу b в файл с именем myfile1.csv, в качестве разделителя значений используем символ табуляции:

write.table(b, file = "myfile1.csv", sep = "\t")

Для чтения данных из текстового файла служит функция read.table(), например:

y <- read.table("myfile1.csv")

Имеется несколько функций (с предопределёнными по умолчанию параметрами) для чтения файлов в формате CSV в случае, если разделителем является запятая:

read.csv(file, header = TRUE, sep = ",", quote = "\"", dec = ".", fill = TRUE, comment.char = "", ...)

или точка с запятой:

read.csv2(file, header = TRUE, sep = ";", quote = "\"", dec = ",", fill = TRUE, comment.char = "", ...)

Можно читать файл CSV из архива ZIP:

data <- read.csv(unz("ИмяАрхива.zip", "ИмяПапкиВнутриАрхива/ИмяФайла.csv"))

Если архив находится в сети Internet:

f <- tempfile()             # Временный файл.
download.file("http://profitraders.com/ftp/public/EURUSD_M1.zip", f)  # Скачали архив из Internet.
data <- read.csv(unzip(f))  # Прочитали из архива файл CSV.
unlink(f)                   # Удалили временный файл.

Получение справки

В RStudio можно выделить любую функцию и нажать клавишу F1 для получения подсказки. Кроме того, имеются функции подсказки для командной строки: help(Имя) или ?Имя. Здесь Имя — это имя функции (можно без кавычек), подсказку по которой мы хотим получить, или строка, обозначающая некоторую операцию, заключённая в одинарные или двойные кавычки, например: help("[[").

Для поиска дополнительной справки имеется функция help.search("Имя") или ??Имя.

Для вывода в консоль примеров использования служит функция examples(Имя).

Для входа в справочную систему имеется команда ?help.

Код, содержащий определение функции, выводится командой body(Имя). Список параметров функции можно узнать, введя команду formals(Имя).

Определение функций

Можно определить собственные функции с любым количеством аргументов (параметров), например:

my.fun <- function(x)  1/(x+1)/sqrt(x)

Здесь мы определили функцию под именем my.fun с одним аргументом $x$ (в языках программирования он называется формальным параметром), которая предназначена для вычисления значения выражения

\[\frac{1}{(x+1)\sqrt{x}}.\]

Напоминаем, что точку в R принято использовать как разделитель в составных именах (в большинстве других языков программирования в таких случаях пишут символ подчёркивания).

После того, как функция определена, её можно вызвать с любым значением (фактическим параметром), например, в командной строке:

> my.fun(2)
[1] 0.2357023

Другой пример: для вычисления интеграла

\[\int_0^\infty\frac{dx}{(x+1)\sqrt{x}};\]

надо вызвать специальную функцию integrate, указав в качестве первого параметра имя нашей функции, а также указав пределы интегрирования lower (нижний) и upper (верхний):

> integrate(my.fun, lower=0, upper=Inf)
3.141593 with absolute error < 2.7e-05

Определение функции может включать в себя выполнение нескольких действий, тогда тело функции заключается в фигурные скобки, а в конце используется оператор return, в котором указывается то значение, которое функция должна вернуть в место её вызова.

Пример функции, которая принимает два параметра и возвращает вектор из двух элементов:

myfun2 <- function(x, y) {
  z1 <- 3*x - y;  z2 <- z1 + y*y
  return(c(z1, z2))
}

Если вызвать эту функцию со значениями 1 и 3, то в результате получим 0 и 9:

> myfun2(1, 3)
[1] 0 9

(продолжение следует...)

Список литературы

Наглядная статистика. Используем R! / А.Б. Шипунов, Е.М. Балдин, П.А. Волкова, А.И. Коробейников, С.А.Назарова, С.В. Петров, В.Г. Суфиянов. – Москва: ДМК Пресс, 2012. – 298 с.
Andrie de Vries, Joris Meys. R for dummies. Wiley, 2012. 406 p.
Paul Teetor. R Cookbook. O’Reilly, 2011. 438 p.
Winston Chang. R Graphics Cookbook. O’Reilly, 2013. 416 p.
Daróczi G. et al. Introduction to R for Quantitative Finance. Packt Publishing, 2013. 164 p.