Sessão 1 - Introdução ao Curso e Criação de Funções

# vetores
(v1 <- 1:3)

[1] 1 2 3

(v2 <- c("R", "Fnde", "Allan"))

[1] "R"     "Fnde"  "Allan"

(v3 <- c(TRUE, FALSE, T))

[1]  TRUE FALSE  TRUE

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

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

# data.frame
(df <- data.frame("col1" = v1, "col2" = v2, "col3" = v3))

  col1  col2  col3
1    1     R  TRUE
2    2  Fnde FALSE
3    3 Allan  TRUE

# ou
# df <- data.frame(v1, v2, v3)
# colnames(df) <- paste("col", 1:3, sep = "")

# lista
(minha_lista <- list(v1, v2, v3, m, df))

[[1]]
[1] 1 2 3

[[2]]
[1] "R"     "Fnde"  "Allan"

[[3]]
[1]  TRUE FALSE  TRUE

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

[[5]]
  col1  col2  col3
1    1     R  TRUE
2    2  Fnde FALSE
3    3 Allan  TRUE

my_read.fun <- function(file, stringsAsFactors=FALSE, ...){
  read.table(file, stringsAsFactors = stringsAsFactors, ...)  
}

OBSERVAÇÕES:

• não utilizamos return(), então o úlitmo objeto avaliado será retornado - que é nosso arquivo de dados lido;

• esse arquivo é lido pela read.table chamada de dentro da nossa my_read.fun

• nossa nova função recebe 3 parâmetros, que por consequência serão passados para read.table de dentro;

• file indica a localização do nosso arquivo, igual em read.table;

• stringsAsFactors já vai de “fábrica” setado como FALSE - que é nosso objetivo;

• os ... indicam que o usuário poderá, caso deseje, ainda passar outros parâmetros (que serão aproveitados em read.table)

  • lembre-se que read.table pode receber outros parâmetros opcionais como header, sep, dec, etc.
  • o argumento … também é útil quando não podemos definir de antemão quais e quantos parâmetros. É o caso da função paste(), por exemplo.

Também teste removendo stringsAsFactors=stringsAsFactors de dentro de read.table:

## sem stringsAsFactors=stringsAsFactors

# 1)
my_read.fun <- function(file, stringsAsFactors=FALSE, ...){
  read.table(file, ...)  
} # não obedece e pega o default de read.table() que eh TRUE
df <- my_read.fun(df.loc, sep=";", header=TRUE,)

Error in file(file, "rt"): cannot open the connection

str(df)

'data.frame':   3 obs. of  3 variables:
 $ col1: int  1 2 3
 $ col2: Factor w/ 3 levels "Allan","Fnde",..: 3 2 1
 $ col3: logi  TRUE FALSE TRUE

#2)
my_read.fun <- function(file, ...){
  read.table(file, stringsAsFactors=FALSE,...)  
} # INFLEXÍVEL - não há opção de mudar para TRUE!
df <- my_read.fun(df.loc, sep=";", header=TRUE,  stringsAsFactors = TRUE)

Error in read.table(file, stringsAsFactors = FALSE, ...): formal argument "stringsAsFactors" matched by multiple actual arguments

# Erro!

# por isso o correto eh a forma com stringsasFactors=stringsAsFactors

Teste agora sem …

# 1)
# sem ... na my_read.fun
my_read.fun <- function(file, stringsAsFactors=FALSE){
  read.table(file, stringsAsFactors=stringsAsFactors, ...)  
} # reclama de parâmetros inexistentes

df <- my_read.fun(df.loc, sep=";", header=TRUE)

Error in my_read.fun(df.loc, sep = ";", header = TRUE): unused arguments (sep = ";", header = TRUE)

# 2)
# sem ... na read.table
my_read.fun <- function(file, stringsAsFactors=FALSE, ...){
  read.table(file, stringsAsFactors=stringsAsFactors)  
} # erro de leitura
df <- my_read.fun(df.loc, sep=";", header=TRUE)

Error in file(file, "rt"): cannot open the connection

# 3)
# sem ... nas duas
my_read.fun <- function(file, stringsAsFactors=FALSE){
  read.table(file, stringsAsFactors=stringsAsFactors)  
}
#df <- my_read.fun(df.loc) # erro de leitura
df <- my_read.fun(df.loc, sep=";", header=TRUE) # erro nos parâmetros

Error in my_read.fun(df.loc, sep = ";", header = TRUE): unused arguments (sep = ";", header = TRUE)

# criando um vetor:
df <- data.frame(col1 = c(1,2,3,NA,5), col2 = c(7,8,9,10,NA))

# verificando os argumentos da função colSums
colSums

function (x, na.rm = FALSE, dims = 1L) 
{
    if (is.data.frame(x)) 
        x <- as.matrix(x)
    if (!is.array(x) || length(dn <- dim(x)) < 2L) 
        stop("'x' must be an array of at least two dimensions")
    if (dims < 1L || dims > length(dn) - 1L) 
        stop("invalid 'dims'")
    n <- prod(dn[id <- seq_len(dims)])
    dn <- dn[-id]
    z <- if (is.complex(x)) 
        .Internal(colSums(Re(x), n, prod(dn), na.rm)) + (0+1i) * 
            .Internal(colSums(Im(x), n, prod(dn), na.rm))
    else .Internal(colSums(x, n, prod(dn), na.rm))
    if (length(dn) > 1L) {
        dim(z) <- dn
        dimnames(z) <- dimnames(x)[-id]
    }
    else names(z) <- dimnames(x)[[dims + 1L]]
    z
}
<bytecode: 0x55ae1f19af28>
<environment: namespace:base>

O método de arguments matching do R faz com que todos os códigos a seguir sejam equivalentes:

colSums(df) #positional

col1 col2 
  NA   NA 

colSums(x=df) #exact

col1 col2 
  NA   NA 

colSums(x=df, na.rm=FALSE) #exact

col1 col2 
  NA   NA 

colSums(na.rm=FALSE, x=df) #exact

col1 col2 
  NA   NA 

colSums(na=FALSE, df) #partial & positional (descobriu um que não era o primeiro, o próximo é lido como x=)

col1 col2 
  NA   NA 

colSums(na.rm=FALSE, df) #exact & positional

col1 col2 
  NA   NA 

# criando um vetor:
vetor1 <- c(1:20)

O método de arguments matching do R faz com que todos os códigos a seguir sejam equivalentes:

sum(vetor1) #positional

[1] 210

sum(x=vetor1) #exact

[1] 210

sum(x=vetor1, na.rm=FALSE) #exact

[1] 210

sum(na.rm=FALSE, x=vetor1) #exact

[1] 210

sum(na=FALSE, vetor1) #partial & positional (descobriu um que não era o primeiro, o próximo é lido como x=)

[1] 210

sum(na.rm=FALSE, vetor1) #exact & positional

[1] 210

• por definição, o R só utiliza os argumentos que necessariamente forem chamados/ utilizados no código;

• isso se chama lazy evaluation;

• Faça o seguinte teste:

f <- function(a, b){
  a^2
}

f(2)

[1] 4

• Note que, embora houvesse um parâmetro “b”, a função não retornou um erro ao passarmos somente o parâmetro “a”;

• Isso se deve ao processo de lazy evaluation: a função nunca usará o parâmetro (não está no seu corpo), então tanto faz recebê-lo ou não;

• O número 2 passado foi atribuído ao parâmetro “a” via positional matching.

• Vamos construir uma função agora que obrigatoriamente utilizará o parâmetro “b”:

• Faça o seguinte teste:

f <- function(a, b){
  print(a)
  print(b)
}

f("FNDE")

[1] "FNDE"

Error in print(b): argument "b" is missing, with no default

• Neste caso há um erro: o R reclama de não termos passado nenhum valor para o parâmetro “b”

• Dessa vez, o parâmetro “b” é obrigatoriaente utilizado no corpo da função - linha print(b).

power <- function(exponent) {
  function(x) {
    x ^ exponent
  }
}

square <- power(2)
square(2)

Fonte: Advanced R

Resumo da ideia:

• a função do nível mais alto retorna a função do nível mais baixo;
• ao atribuirmos a um nome qualquer, então, estamos atribuindo na verdade uma função àquele nome.
• portanto, o nome square, na verdade, está se tornando um objeto de classe function;
• com isso, estamos criando uma closure.
• seguindo o search path mostrado na Figura, a função de dentro terá acesso ao environment da função de cima e as variáveis lá contidas. - isso seguinifica que a função square() terá acesso aos parâmetros da função power().

• Mas qual seria um caso prático em que as closures seriam uteis?

  • em casos em que temos que criar funções muito parecidas, mas que mudam só por poucos parâmetros;
  • imagine, por exemplo, que temos que criar uma função que soma 2 aos elementos de um vetor:

add_2 <- function(x) {
  x + 2
}

• Mas e se você descobrisse que para alguns casos deve somar 10, em outros 5 e em outros 7, além do 2?

  • para não ter que criar mais três funções diferentes, como todos envolvem soma e diferenciam-se apenas pelo número a ser adicionado, podemos criar closures para esses casos:

add <- function(x){
  function(a){
    x + a
  }
}

add_2 <- add(2)

add_10 <- add(10)

add_5 <- add(5)

add_7 <- add(7)