Identificar código y salidas

Para hacer más fácil la identificación de los diferentes códigos que se usarán en la página, se emplearán los siguientes colores en las ventanas de código.

Para el código presentado en R se empleará un fondo de color negro tal como se presenta a continuación.

"Ejemplo código R"

Mientas que, para los resultados o salidas obtenidas en R se empleará un fondo de color gris, tal como se presenta a continuación.

[1] "Ejemplo código de salida"

Palabras reservadas

El lenguaje R posee una serie de palabras reservadas que no permite que sean modificadas debido a que éstas poseen atributos especiales dentro del lenguaje de programación, y por ello, sus nombres no pueden ser usados como nombre de variables, funciones, etc.

El listado de palabras reservadas en el lenguaje R son:



  

    if 
    else 
    repeat 
    while 
    NA_integer_ 
  

  

    for 
    in 
    next 
    break 
    NA_real_ 
  

  

    function 
    TRUE 
    FALSE 
    ... 
    NA_complex_ 
  

  

    NULL 
    NA 
    Inf 
    NaN 
    NA_character_

en donde

  • if, else, repeat, while, function, for, in, next, break: Son funciones usadas en loops, condicionales y funciones.
  • TRUE, FALSE: Son carácteres especiales para indicar constantes lógicas.
  • NULL: Es un carácter especial para indicar valores indefinidos o indicar la no existencia de valor dentro de la base de datos o de una entrada de la misma.
  • Inf (Infinity): Es un carácter especial para indicar que un número u operación da como resultado un número infinito o excesivamente grande.
  • NaN (Not a number): Es un carácter especial para datos de clase numérica, para indicar un valor asociado a un cálculo cuyo resultado es desconocido, el cual seguramente no es un número. Este puede obtenerse mediante operaciones tales como $0/0$, $Inf/Inf$, $Inf-Inf$.
  • NA (Not Available): Es un carácter especial para indicar valores perdidos o faltantes.
  • NA_integer_, NA_real_, NA_complex_, NA_character_: Son carácteres especiales que indican valores perdidos o faltantes para diferentes tipo de vectores atómicos.
  • $\text{… }$: Es un carácter especial que se emplea para permitir a una función pueda configurarse con los argumento a otra función.

El listado palabras reservadas en el lenguaje R también pueden ser consultadas en mediante el código

?reserved

Estructura de asignación

Generalmente cuando se trabaja en programación, se desea que el programa recuerde ciertos valores para usarlos más adelante, y por ello, la idea de esta sección es explicar los métodos de asignación de objetos.

La estructura de asignación en el lenguaje R puede llevarse a cabo mediante cuatro formas diferentes, donde, cada una de ellas lleva al mismo resultado

variable <- objeto       # Primer método
objeto -> variable       # Segundo método
variable = objeto        # Tercer método
assign(variable, objeto) # Cuarto método

De estos cuatro métodos de asignación presentados, el primero y el segundo poseen la misma estructura, la diferencia entre ellos radica en que, el primero realiza la asignación a la izquierda y el segundo a la derecha, lo cual depende de la dirección hacia donde apunte la flecha.

El tercer método, a pesar de realizar la asignación al igual que los dos primeros métodos, éste no es el operador habitual de asignación, pues éste se encuentra reservado para otros propósitos, tales como darle valores a una variable dentro de una función. El cuarto método, es una forma de asignación equivalente a las dos primeras, pero requiere de “más esfuerzo” para llevarse acabo la asignación.

Por lo tanto, se recomienda emplear el primer método de asignación. Es de anotar que el simbolo <- puede escribirse de dos formas, presionando la tecla < seguida de la tecla -, o alternativamente, presionando de forma simultanea las teclas Alt y la tecla -.

También se señala que el carácter #, se emplea para comentar el código o una línea específica, lo cual implica que posterior a #, no se ejecutará ningún tipo de código en la linea específica en la cual se encuentre #.

Ayuda sobre funciones

En muchas situaciones, podemos conocer la función que deseamos emplear pero no sabemos con exactitud cuales son los argumentos o el significado de los mismos, lo cual hace que no podamos usar adecuadamente la función de interés.

Es por ello que tanto R posee información, sobre las funciones que pueden emplearse en los lenguajes de programación, mostrando los diferentes argumentos que posee, su significado, los valores que pueden extraerse de la función y ejemplos sobre su empleo.

Para obtener información sobre una función concreta o carácter en R, existen dos métodos que permiten abrir la ventana de ayuda, el primero es mediante la función help(), la segunda es mediante el signo ?. Para ilustrar dichos métodos, empleamos la función if() y el carácter +, para consultar su ventana de ayuda.

help("if")  # Primer método
?"+"        # Segundo método

Operadores aritméticos y precedencias

Existen diferentes operadores aritméticos que pueden emplearse en los lenguajes de programación. Estos se resumen en la siguiente tabla.


 
  

    Operación 
    Operador en R 
    Asociatividad 
    Precedencia 
  

 

  

    Potencia 
    ^ 
    Por la derecha 
    1 
  

  

    Producto 
    * 
    Por la izquierda 
    2 
  

  

    División 
    / 
    Por la izquierda 
    2 
  

  

    División Entera 
    %/% 
    Por la izquierda 
    2 
  

  

    Módulo o Resto 
    %% 
    Por la izquierda 
    2 
  

  

    Suma 
    + 
    Por la izquierda 
    3 
  

  

    Resta 
    - 
    Por la izquierda 
    3

Operadores lógicos

También es posible que se quieran realizar operaciones lógicas entre objetos cuando se realiza programación en los diferentes lenguajes, ya sea para establecer condicionales, o para hacer algunas verificaciones. Estos se resumen en la siguiente tabla.

Operación Operador en R Precedencia
Igual que == 4
Distinto que != 4
Menor que < 4
Menor o igual que <= 4
Mayor que > 4
Mayor o igual que >= 4
Conjunción & 5
Disyunción | 5
Negación ! 6
Asignación <- 7

Funciones matemáticas

Hay una gran variedad de funciones matemáticas que suelen usarse en la práctica, y es por ello que se listan las funciones aritméticas que suelen emplearse comunmente por lenguaje de programación. Estos se resumen en la siguiente tabla.

Operación Operador en R
Valor absoluto abs()
Raíz cuadrada sqrt()
Redondear round()
Techo ceiling()
Piso floor()
Exponencial exp()
Logaritmo log()
Factorial factorial()
Gamma gamma()
Seno sin()
Coseno cos()
Tangente tan()

Tipo de datos

Existen diferentes tipos de datos en los lenguajes de programación, de estos tipos dependerá las operaciones o funciones que pueden o no emplearse con éstos, y es por ello que debe tenerse especial cuidado cuando se deseen manipular.

Los tipos de datos más que pueden encontrarse en R son:

  • numeric: Datos númericos, los cuales soportan números que se encuentren en el conjunto de los reales, $\mathbb{R}$, y por tanto soporta tanto números enteros (integer) y números de doble presición (double).
  • integer: Datos enteros, los cuales soportan números que se encuentren en el conjunto de los enteros, $\mathbb{Z}$, y en consecuencia, solo soporta números enteros.
  • complex: Datos complejos, los cuales soportan números que se encuentren en el conjunto de los complejos, $\mathbb{C}$, y por tanto, soporta tanto números reales como imaginarios.
  • character: Datos de carácter, los cuales soportan carácteres alfanuméricos, es decir, datos numéricos y alfabéticos. Éstos deben ser escritos entre comillas simples o dobles.
  • factor: Datos categóricos nominales, los cuales soportan carácteres alfanuméricos, y establece entre estos diferentes categorías. Se puede emplear la función factor() para crear datos de este tipo. Éstos deben ser escritos entre comillas simples o dobles.
  • ordered: Datos categóricos ordinales, los cuales soportan carácteres alfanuméricos, y establece entre estos diferentes categorías junto con una estructura jerarquíca. Se puede emplear la función ordered() para crear datos de este tipo. Éstos deben ser escritos entre comillas simples o dobles.
  • logical: Datos lógicos, los cuales soportan carácteres lógicos tales como TRUE o FALSE.

Para verificar al estructura de almacenamiento en R, puede emplearse la función str(), mientras para observar la estructura de almacenamiento pueden emplearse las funciones mode(), typeof, y para observar la clase interna del objeto puede emplearse la función class().

A continuación se presenta un ejemplo en donde se muestran los diferentes tipos de objetos en R

Dato tipo numérico 

# Numeric
a <- 3.3
str(a)

 num 3.3

Dato tipo entero 

# Integer
b <- 3L
str(b)

 int 3

Dato tipo lógico 

# Complex
c <- 3 + (0+0.2i)
str(c)

 cplx 3+0.2i

Dato tipo carácter 

# Character
d <- "Ejemplo :D"
str(d)

 chr "Ejemplo :D"

Dato tipo factor 

# Factor
e <- factor("Otro ejemplo :o")
str(e)

 Factor w/ 1 level "Otro ejemplo :o": 1

Dato tipo ordinal 

# Ordered
f <- ordered("Uno más >:o")
str(f)

 Ord.factor w/ 1 level "Uno más >:o": 1

Dato tipo lógico 

# logic
g <- FALSE
str(g)

 logi FALSE

Estructura de datos

La idea de esta sección es resumir las estructuras básicas más importantes que puede tener un conjunto de datos en R.

Dichas estructuras se pueden organizar por su dimensionalidad ($1d$, $2d$ o $nd$) y si permiten o no diferentes tipos de objetos a la vez (homogeneidad o heterogeneidad).

Para resumir la estructura de datos en R, podemos remitirnos a la siguiente tabla.

Homogeneos Heterogeneos
\(1d\) Vector Atómico
\(2d\) Matriz Marco de datos
\(nd\) Arreglos Lista
  • Vector: este objeto admite datos númericos, carácteres, complejos o lógicos, pero solo permite un solo tipo de dato a la vez. Puede construirse mediante la función c().

Representación de un Vector

A continuación se presenta un ejemplo en donde se muestra como construir vectores para diferentes tipos de datos en R 

VecA <- c(1, 4, 5, -6.2, -3-2i)  # Numeric
VecA

[1]  1.0+0i  4.0+0i  5.0+0i -6.2+0i -3.0-2i

VecB <- c("a", "c", "a", "b", "c", "a")  # Character
VecB

[1] "a" "c" "a" "b" "c" "a"

VecC <- factor(VecB)  # Factor
VecC

[1] a c a b c a
Levels: a b c

VecD <- ordered(VecB)  # Ordered
VecD

[1] a c a b c a
Levels: a < b < c

VecE <- c(F, T, NA, F, T, F)  # Logic
VecE

[1] FALSE  TRUE    NA FALSE  TRUE FALSE
  • Matriz: este objeto admite datos númericos, carácteres, complejos o lógicos, pero solo permite un solo tipo de dato a la vez. Puede construirse mediante la función matrix().

Representación de un Matriz

A continuación se presenta un ejemplo en donde se muestra como construir matrices para diferentes tipos de datos en R 

MatA <- matrix(data = c(1, 4, 5, 6, 2, 3), nrow = 3, ncol = 2, byrow = T)  # Numeric
MatA

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

MatB <- matrix(data = c("a", "c", "a", "b", "c", "a"), nrow = 2, ncol = 3, byrow = F)  # Character
MatB

     [,1] [,2] [,3]
[1,] "a"  "a"  "c" 
[2,] "c"  "b"  "a" 

MatC <- matrix(data = c(VecE, T, T, F), nrow = 3, ncol = 3, byrow = F)  # Lógico
MatC

      [,1]  [,2]  [,3]
[1,] FALSE FALSE  TRUE
[2,]  TRUE  TRUE  TRUE
[3,]    NA FALSE FALSE
  • Arreglos: Permite datos numericos, carácteres, complejos o lógicos, pero solo permite un solo tipo de dato a la vez. Puede construirse mediante la función array().

Representación de un Arreglo

A continuación se presenta un ejemplo en donde se muestra como construir arreglos para diferentes tipos de datos en R 

ArrA <- array(data = c(1, 4, 5, 6, 2, 3, 2, 3, 4, 1, 2, 4), dim = c(3, 2, 2))  # Numeric
ArrA

, , 1

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

, , 2

     [,1] [,2]
[1,]    2    1
[2,]    3    2
[3,]    4    4

ArrB <- array(data = c(VecB, "o", "m"), dim = c(2, 2, 2))  # Character
ArrB

, , 1

     [,1] [,2]
[1,] "a"  "a" 
[2,] "c"  "b" 

, , 2

     [,1] [,2]
[1,] "c"  "o" 
[2,] "a"  "m" 

ArrC <- array(data = c(VecE, F, F, NA, F, T, NA), dim = c(2, 2, 3))  # Logic
ArrC

, , 1

      [,1]  [,2]
[1,] FALSE    NA
[2,]  TRUE FALSE

, , 2

      [,1]  [,2]
[1,]  TRUE FALSE
[2,] FALSE FALSE

, , 3

      [,1] [,2]
[1,]    NA TRUE
[2,] FALSE   NA
  • Marco de Datos: Permite datos numericos, carácteres, complejos o lógicos, además de permitir multiples tipos por objeto a la vez. Puede construirse mediante la función data.frame().

Representación de un Marco de Datos

A continuación se presenta un ejemplo en donde se muestra como construir un marco de datos en R 

DatF <- data.frame("Numeric" = c(VecA, 8), "Character" = VecB, "Factor" = VecC, "Logic" = VecE)
DatF

  Numeric Character Factor Logic
1  1.0+0i         a      a FALSE
2  4.0+0i         c      c  TRUE
3  5.0+0i         a      a    NA
4 -6.2+0i         b      b FALSE
5 -3.0-2i         c      c  TRUE
6  8.0+0i         a      a FALSE
  • Listas: Permite datos numericos, carácteres, complejos, lógicos, funciones, expresiones, etc, además de permitir multiples tipos por objetos a la vez. Puede construirse mediante la función list().

Representación de listas

A continuación se presenta un ejemplo en donde se muestra como construir una lista de datos en R 

Lista <- list("DataFrame" = DatF, "Matriz" = MatB, "Función" = expression(beta), "Arreglo" = ArrC)
Lista

$DataFrame
  Numeric Character Factor Logic
1  1.0+0i         a      a FALSE
2  4.0+0i         c      c  TRUE
3  5.0+0i         a      a    NA
4 -6.2+0i         b      b FALSE
5 -3.0-2i         c      c  TRUE
6  8.0+0i         a      a FALSE

$Matriz
     [,1] [,2] [,3]
[1,] "a"  "a"  "c" 
[2,] "c"  "b"  "a" 

$Función
expression(beta)

$Arreglo
, , 1

      [,1]  [,2]
[1,] FALSE    NA
[2,]  TRUE FALSE

, , 2

      [,1]  [,2]
[1,]  TRUE FALSE
[2,] FALSE FALSE

, , 3

      [,1] [,2]
[1,]    NA TRUE
[2,] FALSE   NA

Coerción de datos

Muchas veces cuando tenemos una variable, puede que esta no tenga almacenados los datos bajo el tipo que queremos tenerlo realmente, por ello, existen en los lenguajes de programación funciones de coercionar que permiten redefinir un objeto, para transformarlo al tipo que necesitamos.

Coerción de datos en R

Para convertir una variable de un tipo a otro, existen una serie de funciones básicas en R que permiten hacer dicho procedimiento, estas funciones son

  • as.numeric(): Convierte una variable a tipo numérico (double).
  • as.logical(): Convierte una variable a tipo lógico.
  • as.integer(): Convierte una variable a tipo entero.
  • as.factor(): Convierte una variable a tipo factor.
  • as.character(): Convierte una variable a tipo carácter (character).
  • as.ordered(): Convierte una variable a tipo factor asumiendo un orden o jerarquía entre los niveles.