# Introduccion a R: vectores

David Montaner (2014-03-31)

Script que introduce los comandos mas basicos de `R` relacionados con vectores.

    # rm (list = ls ())

## Preliminares

    #esto es una linea comentada

Para salir de R escribir: q () R se puede utilizar como calculadora

    2+2

    #> [1] 4

    2*3

    #> [1] 6

La asignacion de valores se hace utilizando: `<-`

    variableA <- 3
    variableA

    #> [1] 3

    variableA * 2

    #> [1] 6

Todas las funciones en R van siempre seguidas de parentesis que envuelven los argumentos de la funcion

    sqrt (3)

    #> [1] 1.732051

    sqrt (variableA)

    #> [1] 1.732051

    SQRT (variableA)   #R es _case sensitive_ no funciona en mayusculas

    #> Error in eval(expr, envir, enclos): could not find function "SQRT"

    variableA

    #> [1] 3

    VARIABLEA

    #> Error in eval(expr, envir, enclos): object 'VARIABLEA' not found

    sqrt ("variableA") #cada funcion esta definida para un tipo o clase de argumentos

    #> Error in sqrt("variableA"): non-numeric argument to mathematical function

## Clases de variables; la FUNCION class

    class (1)

    #> [1] "numeric"

    class ("adjgfagkjg")

    #> [1] "character"

    class ("1")

    #> [1] "character"

    class (TRUE); class (FALSE)

    #> [1] "logical"

    #> [1] "logical"

    class (factor (1))

    #> [1] "factor"

Las funciones tambien son 'objetos' accesibles en la sesion

    class (ls)

    #> [1] "function"

    ls () # llamada a la funcion: con parentesis, aunque no tenga argumentos

    #> [1] "base"      "bases"     "variableA"

    ls    # llamada a la funcion sin parentesis: muestra el objeto, es decir, el codigo de la función.

    #> function (name, pos = -1L, envir = as.environment(pos), all.names = FALSE,
    #>     pattern, sorted = TRUE)
    #> {
    #>     if (!missing(name)) {
    #>         pos <- tryCatch(name, error = function(e) e)
    #>         if (inherits(pos, "error")) {
    #>             name <- substitute(name)
    #>             if (!is.character(name))
    #>                 name <- deparse(name)
    #>             warning(gettextf("%s converted to character string",
    #>                 sQuote(name)), domain = NA)
    #>             pos <- name
    #>         }
    #>     }
    #>     all.names <- .Internal(ls(envir, all.names, sorted))
    #>     if (!missing(pattern)) {
    #>         if ((ll <- length(grep("[", pattern, fixed = TRUE))) &&
    #>             ll != length(grep("]", pattern, fixed = TRUE))) {
    #>             if (pattern == "[") {
    #>                 pattern <- "\\["
    #>                 warning("replaced regular expression pattern '[' by  '\\\\['")
    #>             }
    #>             else if (length(grep("[^\\\\]\\[<-", pattern))) {
    #>                 pattern <- sub("\\[<-", "\\\\\\[<-", pattern)
    #>                 warning("replaced '[<-' by '\\\\[<-' in regular expression pattern")
    #>             }
    #>         }
    #>         grep(pattern, all.names, value = TRUE)
    #>     }
    #>     else all.names
    #> }
    #> <bytecode: 0x21d3078>
    #> <environment: namespace:base>

## VECTORES

Varios elementos se pueden concatenar en un vector utilizando el operador o funcion: `c ()`

    c (1,2,3)

    #> [1] 1 2 3

    c ("a","b","c")

    #> [1] "a" "b" "c"

    c ("a","b","c", 1,2,3) #OBS: todos los elementos del vector son del mismo tipo

    #> [1] "a" "b" "c" "1" "2" "3"

Todos los elementos del vector tienen la misma clase

    class (c (1,2,3))

    #> [1] "numeric"

    class (c ("a","b","c"))

    #> [1] "character"

    class (c ("a","b","c", 1,2,3)) #Si no R cambia el tipo de alguno de ellos.

    #> [1] "character"

La longitud es una caracteristica de los vectores que se podemos conocer utilizando la funcion length

    length (c (1,2,3))

    #> [1] 3

    length (c ("a","b","c"))

    #> [1] 3

    length (c ("a","b","c", 1,2,3))

    #> [1] 6

Todas las variables en R son vectores de longitud 1

    is.vector (1)

    #> [1] TRUE

    class (1)

    #> [1] "numeric"

    length (1)

    #> [1] 1

    is.vector ("adjgfagkjg")

    #> [1] TRUE

    class ("adjgfagkjg")

    #> [1] "character"

    length ("adjgfagkjg")

    #> [1] 1

    is.vector (TRUE)

    #> [1] TRUE

    class (TRUE)

    #> [1] "logical"

    length (TRUE)

    #> [1] 1

Son lo mismo:

    1

    #> [1] 1

    c (1)

    #> [1] 1

    1 == c (1)

    #> [1] TRUE

    identical (1, c (1))

    #> [1] TRUE

Asignacion de valores a variables

    a <- 4
    a

    #> [1] 4

    b <- c (1,2,3)
    b

    #> [1] 1 2 3

    c <- c (5,4,3,2,1)
    c

    #> [1] 5 4 3 2 1

    d <- c ("a","b","c", "d", "e", "f")
    d

    #> [1] "a" "b" "c" "d" "e" "f"

    length (a)

    #> [1] 1

    length (b)

    #> [1] 3

    length (c)

    #> [1] 5

    length (d)

    #> [1] 6

Se puede reasignar valores

    a

    #> [1] 4

    a <- 7
    a

    #> [1] 7

    a <- c ("a","b","c",)

    #> Error in c("a", "b", "c", ): argument 4 is empty

    a

    #> [1] 7

Los vectores pueden ser de varias CLASES

    class (1:10)               #"integer"

    #> [1] "integer"

    class (c (1.0, 2.0, 3.0))  #"numeric"

    #> [1] "numeric"

    class (c ("A", "B", "C"))  #"character"

    #> [1] "character"

    class (c (TRUE, FALSE))    #"logical"

    #> [1] "logical"

Se puede acceder a los elementos del vector por su poscion

    d

    #> [1] "a" "b" "c" "d" "e" "f"

    d[1]

    #> [1] "a"

    d[3]

    #> [1] "c"

Varias posiciones del vector se indican, a su vez, como un vector numerico

    d[c (1,2,3)]

    #> [1] "a" "b" "c"

    d[c (3,2,1)]  #sigue siendo un vector en otro orden

    #> [1] "c" "b" "a"

quizas sea mas claro asi presentado

    v <- c (3,2,1)
    class (v)  ##es un vector

    #> [1] "numeric"

    d[v]       ##que 'indexa' a otro vector

    #> [1] "c" "b" "a"

    class (d[c (1,2,3)])  #es un vector nuevo

    #> [1] "character"

    length (d[c (1,2,3)]) #con longitud diferente

    #> [1] 3

Se puede acceder a todo el vector menos algunas posiciones

    d

    #> [1] "a" "b" "c" "d" "e" "f"

    d[-1]

    #> [1] "b" "c" "d" "e" "f"

    d[c (-1,-3,-5)]

    #> [1] "b" "d" "f"

    d[ - c (1,3,5)] # el operador - se aplica a todos los elementos del vector

    #> [1] "b" "d" "f"

    d[c (1, 3, -5)] # no se pueden mezclar las dos formas de acceso

    #> Error in d[c(1, 3, -5)]: only 0's may be mixed with negative subscripts

El operador ':' indica una secuencia de enteros

    10:15

    #> [1] 10 11 12 13 14 15

    c (10, 11, 12 ,13 ,14, 15)

    #> [1] 10 11 12 13 14 15

    identical (10:15, c(10, 11, 12 ,13 ,14, 15))

    #> [1] FALSE

    class (10:15)

    #> [1] "integer"

    class (c(10, 11, 12 ,13 ,14, 15))

    #> [1] "numeric"

Al ser un vector, se puede usar para indexar las posiciones de otros

    d[3:1]

    #> [1] "c" "b" "a"

OBS: los vectores tambien se pueden nombrar

    v <- 101:103
    v

    #> [1] 101 102 103

    names (v)

    #> NULL

    names (v) <- c ("n1", "n2", "n3")
    v

    #>  n1  n2  n3
    #> 101 102 103

    names (v)

    #> [1] "n1" "n2" "n3"

de hecho se pueden nombrar al definirlos

    c (N1 = "primer valor", N2 = "segundo valor")

    #>              N1              N2
    #>  "primer valor" "segundo valor"

Podemos acceder a las posiciones de los vectores por sus nombres si las tienen

    v[2]

    #>  n2
    #> 102

    v["n2"]

    #>  n2
    #> 102

    v[3:2]

    #>  n3  n2
    #> 103 102

    v[c("n3", "n2")]

    #>  n3  n2
    #> 103 102

Tambien se puede acceder a los elementos de un vector indexando con vectores 'logicos'

    v

    #>  n1  n2  n3
    #> 101 102 103

    logico <- c(TRUE, FALSE, TRUE)
    is.vector (logico)

    #> [1] TRUE

    class (logico)

    #> [1] "logical"

    v[logico]

    #>  n1  n3
    #> 101 103

## Operaciones entre vectores

Las operaciones entre vectores se realizan entre los elementos de vectores segun la posicion

    c (1,1,2,3) + c (4,5,6,9)

    #> [1]  5  6  8 12

    A <- c (1,1,2,3)
    B <- c (4,5,6,9)

    A + B

    #> [1]  5  6  8 12

    A * B

    #> [1]  4  5 12 27

    B / A

    #> [1] 4 5 3 3

potencias

    A^2

    #> [1] 1 1 4 9

    A^3

    #> [1]  1  1  8 27

potencias (forma alternativa)

    A**2

    #> [1] 1 1 4 9

    3*A ##' es tambien una operacion entre elementos de vectores

    #> [1] 3 3 6 9

        ##' el vector c(3) se extiende automaticamente

    1/A

    #> [1] 1.0000000 1.0000000 0.5000000 0.3333333

    1/B

    #> [1] 0.2500000 0.2000000 0.1666667 0.1111111

Generalmente, vectores de diferente longitud se reciclan en las operaciones

    A

    #> [1] 1 1 2 3

    c (2,3) * A

    #> [1] 2 3 4 9

    c (3,3) * c (1,2,3,4)

    #> [1]  3  6  9 12

    c (1,2) * c (1,2,3,4) #es lo mismo que:

    #> [1] 1 4 3 8

    c (1,2,1,2) * c (1,2,3,4)

    #> [1] 1 4 3 8

La longitud de uno de los vectores ha de ser multiplo de la longitud del otro vector. Este tipo de repeticiones suele funcionar con todas las operaciones entre vectores.

    c (1,2,1) * c (1,2,3,4)

    #> Warning in c(1, 2, 1) * c(1, 2, 3, 4): longer object length is not a
    #> multiple of shorter object length

    #> [1] 1 4 3 4

Missing values: NA (not available)

    m <- c (1:2, NA, 4:6)
    m

    #> [1]  1  2 NA  4  5  6

    class (m)

    #> [1] "integer"

    class (m[3])

    #> [1] "integer"

    m[3]

    #> [1] NA

    n <- c ("a", NA, "b")
    n

    #> [1] "a" NA  "b"

    class (n)

    #> [1] "character"

    class (n[2])

    #> [1] "character"

    n[2]

    #> [1] NA

    is.na (m)

    #> [1] FALSE FALSE  TRUE FALSE FALSE FALSE

    is.na (n)

    #> [1] FALSE  TRUE FALSE

    m

    #> [1]  1  2 NA  4  5  6

    m+1 #los NA se propagan en las operaciones

    #> [1]  2  3 NA  5  6  7

No todas las operaciones entre vectores son numericas. Por ejemplo la funcion para concatenar textos:

    paste ("texto primero", "texto segundo", sep = " ")

    #> [1] "texto primero texto segundo"

    paste ("texto primero", "texto segundo", sep = "_")

    #> [1] "texto primero_texto segundo"

    paste ("texto primero", "texto segundo", sep = " Y ")

    #> [1] "texto primero Y texto segundo"

    paste ( c("texto1", "texto2"), c("TEXTO1", "TEXTO2", "TEXTO3", "TEXTO4"), sep = " ")

    #> [1] "texto1 TEXTO1" "texto2 TEXTO2" "texto1 TEXTO3" "texto2 TEXTO4"

Tambien hay operaciones logicas definidas para los vectores logicos

    vectorlogico <- is.na (m)
    vectorlogico

    #> [1] FALSE FALSE  TRUE FALSE FALSE FALSE

    class (vectorlogico)

    #> [1] "logical"

    length (vectorlogico)

    #> [1] 6

    vectorlogico[1:3]

    #> [1] FALSE FALSE  TRUE

Operadres logicos: NEGACION

    !TRUE

    #> [1] FALSE

    !FALSE

    #> [1] TRUE

    !vectorlogico       ##afectan a todos los elementos del vector

    #> [1]  TRUE  TRUE FALSE  TRUE  TRUE  TRUE

Operadres logicos: Y

    TRUE  & TRUE

    #> [1] TRUE

    TRUE  & FALSE

    #> [1] FALSE

    FALSE & FALSE

    #> [1] FALSE

    c (TRUE, TRUE) & c (TRUE, FALSE)

    #> [1]  TRUE FALSE

Operadres logicos: O

    TRUE | TRUE

    #> [1] TRUE

    TRUE | FALSE

    #> [1] TRUE

    FALSE | FALSE

    #> [1] FALSE

    c (TRUE, TRUE) | c (TRUE, FALSE)

    #> [1] TRUE TRUE

## LOOPS con vectores

    v

    #>  n1  n2  n3
    #> 101 102 103

Iteramos sobre las posiciones:

    posiciones <- 1:3
    posiciones

    #> [1] 1 2 3

    for (i in posiciones) {
      cat ("\n") #linea nueva
      ##
      print (i)
      dato <- v[i]
      print (dato)
    }

    #>
    #> [1] 1
    #>  n1
    #> 101
    #>
    #> [1] 2
    #>  n2
    #> 102
    #>
    #> [1] 3
    #>  n3
    #> 103

Iteramos sobre los nombres del vector:

    nombres <- names (v)
    nombres

    #> [1] "n1" "n2" "n3"

    for (i in nombres) {
      cat ("\n") #linea nueva
      print (i)
      dato <- v[i]
      print (dato)
    }

    #>
    #> [1] "n1"
    #>  n1
    #> 101
    #>
    #> [1] "n2"
    #>  n2
    #> 102
    #>
    #> [1] "n3"
    #>  n3
    #> 103

Iteramos sobre los propios elementos del vector. Es una forma particular de R (no esta en algunos otros lenguajes)

    for (i in v) {
      cat ("\n") #linea nueva
      print (i)
      dato <- i
      print (dato)
    }

    #>
    #> [1] 101
    #> [1] 101
    #>
    #> [1] 102
    #> [1] 102
    #>
    #> [1] 103
    #> [1] 103

Funciones que leen y escriben vectores:

- readLines
- writeLines