David Montaner (2014-03-31)
Script que introduce los comandos mas basicos de R relacionados con vectores.
# rm (list = ls ())
#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
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)
#> {
#> 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))
#> 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: 0x1b935c8>
#> <environment: namespace:base>
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
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
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: