Tipos de funciones en la programación R

Una función es un conjunto de declaraciones orquestadas juntas para realizar una operación específica. Una función es un objeto, por lo que el intérprete puede pasar el control a la función, junto con los argumentos que pueden ser necesarios para que la función realice las acciones. La función, a su vez, realiza la tarea y devuelve el control al intérprete, así como cualquier valor de retorno que pueda almacenarse en otros objetos.
 

¿Cómo definir una función?

En la programación R , una función se puede definir usando la función de palabra clave. La sintaxis para definir una función en R es la siguiente: 
 

Sintaxis:

 
 

function_name = function(arg_1, arg_2, …) 
{ 
Cuerpo de la función 
} 
 

Los diversos componentes/partes de una función son: 
 

• Nombre de la función: Es el nombre real de la función. Se almacena en el entorno R como un objeto con este nombre.
• Argumentos: Un argumento es un marcador de posición. Cada vez que se invoca una función, se pasa un valor al argumento. Son opcionales; es decir, una función puede no contener argumentos. También los argumentos pueden tener valores predeterminados.
• Cuerpo de la función: contiene todo el conjunto de declaraciones que define lo que realmente hace la función.
• Valores devueltos: Son los valores que devuelve la función después de la ejecución exitosa de las tareas. En términos más generales, es la última expresión en el cuerpo de la función que se evaluará.

Llamar a una función

No es más que llamar a la función original con un número válido de argumentos. Se puede llamar a una función con un argumento, sin argumento y también con un valor predeterminado.

Ejemplo: llamar a una función sin un argumento

# create a function cube
# without an argument
cube <- function()
{
  for(i in 1:10)
  {
    print(i^3)
  }
}
 
# calling function cube without an argument
cube()

Producción:

[1] 1
[1] 8
[1] 27
[1] 64
[1] 125
[1] 216
[1] 343
[1] 512
[1] 729
[1] 1000

Ejemplo: Llamar a una función con un argumento.

# create a function factorial
# with a numeric argument n
factorial <- function(n)
{
  if(n==0)
  {
    return(1)
  }
  else
  {
    return(n * factorial(n - 2))
  }
}
 
# calling function cube with an argument
factorial(7)

Producción:

[1] 5040

Ejemplo: llamar a una función con argumento predeterminado.

# create a function def_arg
# without an argument
def_arg <- function(a = 23, b = 35)
{
  output <- (a + b) * a + (a - b) * b
  print(output)
}
 
# calling function def_arg without an argument
def_arg()
 
# call the function with giving new values of the argument.
def_arg(16, 22)

Producción:

[1] 914
[1] 476

Tipos de función

Hay principalmente tres tipos de funciones en la programación R: 
 

1. Funciones primitivas
2. Funciones infijas
3. Funciones de reemplazo

Funciones primitivas

Generalmente, una función se compone de tres partes: 
 

• Los formals() , la lista de argumentos que controlan cómo llamas a la función.
• El cuerpo() , el código dentro de la función.
• El entorno() , la estructura de datos que determina cómo la función encuentra los valores asociados con los nombres.

Los formales y el cuerpo se definen explícitamente cada vez que se crea una función, pero el entorno se especifica implícitamente, en función de dónde defina la función. Pero hay una excepción a la regla de que una función tiene tres componentes, algunas funciones llaman código C directamente. Estas funciones se conocen como funciones primitivas. Las funciones primitivas existen principalmente en C, no en R, por lo que sus formals() , body() y environment() son NULL. Estas funciones solo se encuentran en el paquete base. Las funciones primitivas son más difíciles de escribir pero son muy eficientes. Los hay de dos tipos, ya sea de tipo empotrado o de tipo especial. 
 

typeof(sum)
typeof('[')

[1] "builtin"    #> typeof(sum)
[1] "character"  #> typeof('[')

Ejemplo: para imprimir los nombres de las funciones primitivas disponibles en su consola R, ejecute el siguiente código.

names(methods:::.BasicFunsList)

Producción:

  [1] "$"                    "$<-"                  "["                    "[<-"                  "[["                   "[[="                   "cosh"                 "cummax"               "dimnames<-"          
 [22] "as.raw"               "log2"                 "tan"                  "dim"                  "as.logical"           "^"                    "is.finite"           
 [29] "sinh"                 "log10"                "as.numeric"           "dim<-"                "is.array"             "tanpi"                "gamma"               
 [36] "atan"                 "as.integer"           "Arg"                  "signif"               "cumprod"              "cos"                  "length"              
 [43] "!="                   "digamma"              "exp"                  "floor"                "acos"                 "seq.int"              "abs"                 
 [50] "length<-"             "sqrt"                 "!"                    "acosh"                "is.nan"               "Re"                   "tanh"                
 [57] "names"                "cospi"                "&"                    "anyNA"                "trunc"                "cummin"               "levels<-"            
 [64] "*"                    "Mod"                  "|"                    "names<-"              "+"                    "log"                  "lgamma"              
 [71] "as.complex"           "asinh"                "-"                    "sin"                  "/"                    "as.environment"       "<="                  
 [78] "as.double"            "is.infinite"          "is.numeric"           "rep"                  "round"                "sinpi"                "dimnames"            
 [85] "asin"                 "as.character"         "%/%"                  "is.na"                ""                    "Im"                  
 [92] "%%"                   "trigamma"             "=="                   "cumsum"               "atanh"                "sign"                 "ceiling"             
 [99] "Conj"                 "as.call"              "log1p"                "expm1"                "("                    ":"                    "="                   
[106] "@"                    "{"                    "~"                    "&&"                   ".C"                   "baseenv"              "quote"               
[113] "<-"                   "is.name"              "if"                   "||"                   "attr<-"               "untracemem"           ".cache_class"        
[120] "substitute"           "interactive"          "is.call"              "switch"               "function"             "is.single"            "is.null"             
[127] "is.language"          "is.pairlist"          ".External.graphics"   "globalenv"            "class<-"              ".Primitive"           "is.logical"          
[134] "enc2utf8"             "UseMethod"            ".subset"              "proc.time"            "enc2native"           "repeat"               "<<-"                 
[141] "@<-"                  "missing"              "nargs"                "isS4"                 ".isMethodsDispatchOn" "forceAndCall"         ".primTrace"          
[148] "storage.mode<-"       ".Call"                "unclass"              "gc.time"              ".subset2"             "environment<-"        "emptyenv"            
[155] "seq_len"              ".External2"           "is.symbol"            "class"                "on.exit"              "is.raw"               "for"                 
[162] "is.complex"           "list"                 "invisible"            "is.character"         "oldClass<-"           "is.environment"       "attributes"          
[169] "break"                "return"               "attr"                 "tracemem"             "next"                 ".Call.graphics"       "standardGeneric"     
[176] "is.atomic"            "retracemem"           "expression"           "is.expression"        "call"                 "is.object"            "pos.to.env"          
[183] "attributes<-"         ".primUntrace"         "...length"            ".External"            "oldClass"             ".Internal"            ".Fortran"            
[190] "browser"              "is.double"            ".class2"              "while"                "nzchar"               "is.list"              "lazyLoadDBfetch"     
[197] "...elt"               "is.integer"           "is.function"          "is.recursive"         "seq_along"            "unlist"               "as.vector"           
[204] "lengths"   

Funciones infijas

Las funciones infijas son aquellas funciones en las que el nombre de la función se encuentra entre sus argumentos y, por lo tanto, tienen dos argumentos. R viene con una serie de operadores infijos integrados como :, ::, :::, $, @, ^, *, /, +, -, >, >=, <, <=, ==, ! =, !, &, &&, |, ||, ~, <- y <<- . Uno puede crear sus propias funciones infijas que comienzan y terminan con %. El nombre de una función infija es más flexible ya que puede contener cualquier secuencia de caracteres excepto %. Hay algunos operadores infijos predefinidos en la programación R. 

Ejemplo: Cree una función de dos argumentos que proporcione el mayor de dos números y vincúlela a un nombre que comience y termine con %.

# R program to illustrate
# Infix function
 
'%Greater%' <- function(a, b)
{
  if(a > b) print(a)
  else if(b > a) print(b)
  else print("equal")
}
5 %Greater% 7
2300 %Greater% 67

Producción:

[1] 7
[1] 2300

Funciones de reemplazo

Las funciones de reemplazo modifican sus argumentos en su lugar (la modificación de un objeto R generalmente crea una copia). El nombre de las funciones de reemplazo siempre va seguido de <. Deben tener argumentos llamados x y valor, y devolver el objeto modificado. En caso de reemplazo, una función necesita argumentos adicionales, los argumentos adicionales deben colocarse entre x y valor, y deben llamarse con argumentos adicionales a la izquierda. El nombre de la función tiene que estar entrecomillado ya que es un nombre sintácticamente válido pero no estándar y el analizador interpretaría <- como el operador no como parte del nombre de la función si no estuviera entrecomillado.
 

Sintaxis:

“nombre_función<-” <- función(x, argumentos adicionales, valor) 
{ 
cuerpo de la función 
} 
 

Ejemplo:

# R program to illustrate
# Replacement function
 
"replace<-" <- function(x, value)
{
  x[1] = value
  x
}
x = rep.int(5, 7)
replace(x) = 0L
print(x)

Producción:

[1] 0 5 5 5 5 5 5