Функции - продвинутый уровень

Про функцию в R можно сказать, что это объект “первого класса” - т.е. это такой же объект, как и любой другой в R, например, вектор.

Функция как объект R

\*Вызовем функцию c(ombine) на двух функциях. С помощью функции str посмотрим, что получилось

str(c(mean, max))

List of 2
 $ :function (x, ...)  
 $ :function (..., na.rm = FALSE)  

Видим, что это список из двух функций Значит ли это такой список (комбинацию функций) можно, например, использовать в sapply? Да, можно 1. Запишу список-комбинацию в переменную

fun_list <- c(mean, max)
?sapply

2. Использую эту комбинацию в sapply

sapply(fun_list, function(f) f(1:100))

[1]  50.5 100.0

N.B! Интересно, то, что стандартный порядок аргументов sapply как-будто бы перевнулся наизнанку. В стандартных ситуациях, которые рассматривались ранее:
* первым аргументом шел объект, к которому собирались, применить функцию
* вторым шла уже сама функция

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

Функция как аргумент функции

Так, например, можно сделать функцию apply_f, а ее сделать аргументом функции sapply

apply_f <- function(f, x) f(x)
sapply(fun_list, apply_f, x = 1:100)

[1]  50.5 100.0

Получаю ответ такой же, как и в примере выше. Смысл в том, что apply_f просто применяет функцию f к аргументу x (“function(f, x) f(x)”). А в sapply эта функция, получается, просто передает функции fun_list аргумент “x = 1:100”.

Точно так же в переменную можно сохранить анонимную функцию - она ничем не хуже любой другой функции.

apply_f(function(x) sum(x^2), 1:10)

[1] 385

Т.е. в примере выше мы аргумент “1:10” передаем анонимной функции, в которой скомбинирована функция “sum(x^2)”, т.е. сумма (1:10)^2.

Как я понимаю применение анонимной функции на данном этапе? По сути анонимная функция помогает нам применять, какие-то относительные сложные комбинации нескольких функций без их записывания в память компа под видом оболочки какой-то единой функции. Т.е. вместо того, чтобы создавать функцию sum_sq и изредка применять ее, только забивая ей память

sum_sq <- function(x) {
  sum(x^2)
}

sum_sq(1:10)

[1] 385

Функция как возвращаемое значение из функции (return value)

Пример: заведем функцию, которая в своем теле возвращает еще 1 функцию

square <- function() function(x) x^2
square()

function(x) x^2
<environment: 0x00000221dee6a198>

Видим, что если прописать такую пустую фнкцию без аргумента, то нам возвращается вложенная в нее функция. А значть можем открыть еще 1 скобки для того, чтобы отдать аргумент такой вложенной функции, например:

square()(5)

[1] 25

Фукнции внутри функций

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

Когда может потребоваться?
Например, когда нам приходится заводить, какую-то специальную функцию для исполнения другой. Тогда код такой функции вкладываем просто в тело зависимой функции и вуаля.

f <- function(x) {
  g <- function(y) if (y >0) 1 else if (y < 0) -1 else 0
  sapply(x, g)
}

Т.е. смысл такой вложенной функции из примера, что она будет дополнительно проверять знак (+/-) аргумента x (каждого элемента вектора

f(-1:3)

[1] -1  0  1  1  1

Конечно, такая функция есть и в базовом R - это функция sign

all.equal(f(-100:100), sign(-100:100))

Определение функции внутри функции - один из вариантов инкапсуляции в R. Способ спрятать функцию от глоабльного окружения

Исходный код функции или как понять, что делает функция?

Можно заглянуть в справку. Но иногда этого может быть недостаточно. Простейший случай - пропечатать имя функции без скобок. Например:

f <- function(x) x^5
f(2)

[1] 32

f

function(x) x^5

Но иногда вывод отличается от стандартного R кода. В выводе могут встретится .C, .Fortran, .External, .Internal, .Primitive - это обращенгие к уже скомпилированному коду на более низкоуровневом языке, чаще всего C - в такой ситуации нужно искать исходный код самого R. Это может быть геморно, но, в принципе, при желании возможно.

Если в выводе есть UseMethod или standardGeneric, то это значит, что происходит т.н. method dispatch для двух систем классов S3/S4 (полиморфизм, например, plot)

methods(plot)

 [1] plot.acf*           plot.data.frame*   
 [3] plot.decomposed.ts* plot.default       
 [5] plot.dendrogram*    plot.density*      
 [7] plot.ecdf           plot.factor*       
 [9] plot.formula*       plot.function      
[11] plot.hclust*        plot.histogram*    
[13] plot.HoltWinters*   plot.isoreg*       
[15] plot.lm*            plot.medpolish*    
[17] plot.mlm*           plot.ppr*          
[19] plot.prcomp*        plot.princomp*     
[21] plot.profile.nls*   plot.raster*       
[23] plot.spec*          plot.stepfun       
[25] plot.stl*           plot.table*        
[27] plot.ts             plot.tskernel*     
[29] plot.TukeyHSD*     
see '?methods' for accessing help and source code

Видим, что количество объектов внутри функции plot довольно большое, т.е. для каждой определено свое поведение функции plot.

Возвращаемое значение из функции

Определяется
А) ключевым словом return:

has_na <- function(v) {
  for (k in v) if (is.na(k)) return(TRUE)
    return(FALSE)
}

Какое первое return в теле функции встречается и исполняется, то и выводится, в случае если их несколько
Б) либо последним вычисленным значением
Например, почитал справку по is.na и понял, что она векторизована и справится с моей задачей лучше и быстрее самопала с циклом

has_na <- function(v) any(is.na(v))

Здесь return нет, только результат is.na, который и будет возвращен

Аргументы функций по умолчанию

Можно посмотреть на аргументы по умолчанию по тому, как объявляется какая-нибудь функция. Например, возьмем seq

args(seq)

function (...) 
NULL

seq(from = 1, to = 1, by = ((to - from)/(length.out - 1)), length.out = NULL, along.with = NULL, …)

• все аргументы могут иметь значения по умолчанию
  
• значения могут вычисляться на лету (в данном примере так происходит с аргументом by)

seq() #from = 1, to = 1

[1] 1

seq(1, 5, length.out = 11) 

 [1] 1.0 1.4 1.8 2.2 2.6 3.0 3.4 3.8 4.2 4.6 5.0

# то же самое, как если бы указали "by = (5-1)/(11-1)"

Правила разбора аргументов

Во многих функциях аргументов много, сложная структура, есть двоеточия и т.д.

Приведем пример 

f <- function(x, pow =2) x^pow
integrate(f, 0, 1) #lower = 0, upper = 1, pow = 2

0.3333333 with absolute error < 3.7e-15

Как разбирается такая функция?
Разбор проходит в 3 этапа:
1. Точное совпадение имени аргумента - arg2, optional_arg
2. Частичное совпадение имени аргумента (только до …) - remove_na
3. Разбор аргументов по позиции - arg1
Неразобранные аргументы попадают в … - do_magic. Из этого многоточия такие пойманные аргументы можно потом достать

Аргумент … (ellipsis) - проброс аргументов

Один из случаев использования ellipsis - “произвольное количество передаваемых объектов” внутри какой-нибудь функции. Так, например, устроены функции sum, c, cbind, paste.

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

integrate(f, 0, 1, pow = 5)

0.1666667 with absolute error < 1.9e-15

Я хочу проинтегрировать функцию от нуля до 1, для этого можно воспользоваться функцией integrate. В примере выше, поскольку мы не указываем дополнительной информации касательно степени, то принимается значение по умолчанию. Рассмотрим пример ниже:

1 + 1

[1] 2

"+" (1, 1)

[1] 2

Все вроде бы то же самое, но теперь в аргументах функции integrate указали аргумент pow = 5 (нет даже аргумента, начинающегося с pow). Важно то, что такого аргумента фукнция integrate не знает, а значит она попытается “пробросить” его вверх по лесенке вложенной в нее функции, которая в нашем примере знает такой аргумент, принимает его и изменяет свое действие в соответствии с поступившей информацией.

Это удобный способ в R использования параметров, которые понадобятся последующим функциям

Бинарные операторы

В R можно создавать не только свои функции, но и бинарные операторы (например, арифметические, такие как “+” или "*", а также специальные операторы %in%, где между %in% символ).

Для начала о бинарных операторах - это тоже функции, которые можно вызвать аналогично другим функциям. Например, все перечисленные ниже выражения эквивалентны

1:5 %in% c(1,2,5)

[1]  TRUE  TRUE FALSE FALSE  TRUE

"%in%" (1:5, c(1, 2,5))

[1]  TRUE  TRUE FALSE FALSE  TRUE

1:5 %in% c(1,2,5)

[1]  TRUE  TRUE FALSE FALSE  TRUE

Давайте проверим, есть ли вхождения x в y

"%nin%" <- function(x, y) !(x %in% y)
1:5 %nin% c(1,2,5)

[1] FALSE FALSE  TRUE  TRUE FALSE

А теперь хочу создать свой собственный бинарный оператор

"%nin%" <- function(x, y) !(x %in% y)
1:5 %nin% c(1,2,5)

Глоссарий: ?“function” ?methods argumet matching ellipsis (?“…”)