jueves, 29 de septiembre de 2011

"R" you ready for R? comandos básicos (Clase 1)

###########################################################################
# Análisis de datos estadísticos con R #
# MANEJO DE DATOS #
# 2011/2012 # # Msc. Rosana Ferrero #
###########################################################################
# Clase 1. Introducción a R
###########################################################################
# 0. Antes de comenzar #
# 1. R como calculadora: Aritmética y Funciones básicas #
# 2. R como lenguaje: objetos en R #
###########################################################################
 
 
###########################################################################
# 0. Antes de comenzar #
###########################################################################
 
# Ayuda detro del programa
?rnorm
help("rnorm")
help.start() # abre la ayuda en html
?help.search
help.search("normal") # lista de funciones o paquetes donde aparece una palabra
?apropos
apropos("normal")
?demo
demo() # lista de las demotraciones disponibles
demo(graphics)
demo(persp)
demo(lm.glm)
example("mean") # ejemplos de aplicación
vignette("sandwich") # descarga un pdf del paquete sandwich
 
# Listado y remoción de objetos en memoria
ls() # para saber los objetos que tenemos en el espacio de trabajo
x # escribir el nombre de un objeto muestra su contenido
save(<objetos>,file="nombre.RData") # para guardar el contenido del espacio de trabajo. También se puede usar: save.image() , si queremos que guarde todo.
attach("misdatos.RData") # para acceder a los objetos de la carpeta de trabajo
detach("misdatos.RData") # para deshacer la selección
rm("x") # borra el objeto "x", y rm() todo el escritorio de trabajo
 
###########################################################################
# 1. R como calculadora: Aritmética y Funciones básicas #
###########################################################################
 
# operaciones aritméticas básicas
2 + 3 # suma
2 - 3 # resta
2*3 # multiplicación
2/3 # división
2^3 # potenciación
 
exp(3) #exponencial
sqrt(2) # raíz cuadrada
log(1) # logaritmo
sin(1); cos(1); tan(1) # trigonométricas
max; min; range; mean; sum; diff; cumsum; sd; quantile # otras
 
#operadores lógicos
<, >, <=, =>, ==, !=
!, &, |, xor()
&&, ||
if()
 
# precedencia de operaciones
4^2 - 3*2
1 - 6 + 4
2^-3
(4^2) - (3*2) # usar paréntisis para agrupar, clarifica
 
# Funciones, argumentos en las funciones
log(100)
log(100, base=10)
log10(100) # equivalente
log(100, b=10) # argumentos abreviados
log(100, 10) # argumentos por posición
x<-log(100, 10) # generación de objetos
 
###########################################################################
# 2. R como lenguaje: objetos en R #
###########################################################################
 
# Creación de objetos y funciones básicas
rnorm(5)
x<-rnorm(5)
x # equivalente a print(x)
plot(x)
summary(x)
 
# Tipos de objetos: vector, array, matriz, factor, lista, hoja de datos, función
x<-1:10; str(x)
# Vector: colección ordenada de elementos del mismo tipo
x<-c(1,2,3) ; y<-c("a", "b", "c") #concatenación "c"
z<-c(TRUE, TRUE, FALSE)
is.vector(x); is.vector(y); is.vector(z)
x[1] ; y[2]; z[3] #cómo acceder a los elementos del vector
 
# Matrices y Array: generalización multidimensional del vector. Elementos del mismo tipo. Varias columnas (o filas) de vectores
is.array(x)
a<-array(9,dim=c(5,4)); a; a[1,]; a[1,,drop=FALSE]
b<-matrix(1:20,nrow=5); b; b[1,2]
 
# Data frame: similar al array, pero con columnas de diferentes tipos.
dates<-data.frame(ID=c("gen0","genB","genZ"),subj1=c(10,25,33),subj2=c(NA,34,15),oncogen=c(TRUE, TRUE, FALSE),loc=c(1,30,125))
data(iris); iris # carga la hoja de datos "iris"
 
# Factor: tipo de vector para datos cualitativos (o categóricos)
x<-factor(c(1,2,2,1,1,2,1,2,1))
 
# List: vector generalizado. Sus componentes pueden ser también listas, o pueden ser de distinto tipo. No tienen estructura.
una.lista<-c(un.vector=1:10,una.palabra="hola",una.matriz=matrix(rnorm(20),ncol=5),lista2=c(1=5,b=factor(c("a","b"))))
 
#Funciones: código
f1<-function(x) {return(2*x)} ; is.function(f1)
 
# Atributos de los objetos
x<-1:15; y<-matrix(5,3,4); z<-c(TRUE, FALSE)
attributes(x); attributes(y); attributes(z)
 
w<-list(a=1:3,b=5); attributes(w)
f1<-function(x) {return(2*x)} ; attributes(f1); is.function(f1)
 
# Modo (mode): lógico, entero, real, carácter, etc.
mode(x); mode(y); mode(z)
 
# Tipo (typeof): double, character...
x1<-1:5, x2<-c(1,2,3,4,5); x3<-"patata"
typeof(x1); typeof(x2); typeof(x3)
 
# Nombres (names): etiquetas.
#Poner un nombre en minúscula no es lo mismo que ponerlo en mayúscula (R es "case-sensitive": x!=X)
#Hay nombres reservados, por lo que hay que evitarlos. Ej: "function", "if"
z <- list(a=1, b="c", c=1:3)
names(z)
 
# Dimensiones (dim): número de filas y columnas (puede ser cero)
length(x)
dim(y)
 
# Nombres de las dimensiones de los arrays (dimnames)
y<-matrix(5,3,4)
dimnames(y)[[1]]<-c("8am","9am","10am") # [[1]] para filas y [[2]] para columnas
colnames(y)<-c("lunes", "martes", "miércoles", "jueves") # alternativa
 
# Clase (class): lista de las clases del objeto (vector alfa-numérico)
x <- 10
class(x) # "numeric"
 
# Otros: por ejemplo, para series temporales.
 
### Indexación o referenciación
x<-1:5; x[1]
x[x>3]
y<-x>3; x[y]
 
names(x)<-c("a","b","c","d","e"); x["c"]
 
data(iris)
iris
iris[,1] # igual que iris[[1]]
iris[1,]
iris[2:4, ]
iris[1, 1:2]
iris$Sepal.Length # referencia a la columna "Sepal.Length" utilizando el formato dataframe$columna
attach(iris); mean(Sepal.Length); detach(iris) # referencia a los nombres de las variables (columnas) mediante la función attach
 
### Valores ausentes: NA (not available); NaN (not a number); Inf (infinito)
x<-c(1:3,NA); is.na(x); which(is.na(x))
x[is.na(x)]<-0 #sustituir NA por 0
is.na(5/0)
is.nan(0/0)
is.infinite(-5/0)
mean(x,na.rm=TRUE) #quitar NA al evaluar la media
x<-c(1:3,NA); y<-na.omit(x); y #para funciones de modelado como lm es mejor usar "na.omit" o "na.exclude", que eliminan los NA
 
### Ordenar vectores
x<-c(5,1,8,3)
order(x); order(x,decreasing=TRUE)
sort(x)
rank(x)
x[order(x)]
x[order(x,decreasing=TRUE)]
 
### Generación de secuencias
# Secuencias aleatorias
sample(5)
sample(5,3)
x<-1:10;sample(x); sample(x,replace=TRUE)
probs<-x/sum(x);sample(x,prob=probs)
 
# Secuencias discretas y continuas
x<-c(1,2,3,4,5)
x<-1:5
x<-seq(from=1,to=5,by=1)
 
# Secuencias con repeticiones
rep(1,5)
x<-1:4; rep(x,2)
gl(3,5) #como rep(1:3, rep(5,3))
expand.grid(1:3,4:6,7:10)
 
### Vector de caracteres
pegar<-paste(c("A","B"),2:3,sep=""); pegar
substr("abcdef",2,4)
y<-factor(1:5); y
 
x <- c(as = "asfef", qu = "qwerty", "yuiop[", "b", "stuff.blah.yech")
# split x on the letter e
strsplit(x, "e")
 
### Discretizar
v<-1:9
cut1<-cut(v,3); cut1
cut2<-cut(v,quantile(v,c(0, 1/3, 2/3, 1)),include.lowest=TRUE); cut2
cut3<-cut(v,quantile(v,c(0, 1/3, 2/3, 1)),include.lowest=TRUE); cut3
 
### Combinar vectores o matrices
rbind(1:5,1:10)
cbind(1:5,1:10)
 
a<-matrix(rnorm(20),ncol=5)
mediai<-media<-NULL;for(i in 1:4){mediai<-mean(a[i,]); media<-c(media,mediai)} # loop
apply(a,1,mean,na.rm=TRUE) # aplica una función a filas, columnas o ambas. Hay que especificar el "margin"
sapply(a,mean,na.rm=TRUE) # simplifica el resultado a un vector o una matriz
lapply(a,mean,na.rm=TRUE) # devuelve una lista
require(stats); groups <- as.factor(rbinom(32, n = 5, prob = 0.4))
tapply(groups, groups, length)
aggregate(state.x77, list(Region = state.region), mean)
 
### Programar en R
#Definición de funciones
funcion1<-function(A,B,C) {x1<-A*B/C; x1}
#Argumentos
args(funcion1)
funcion1(1,2,3)
#Control de ejecución: condicionales, loops
f = factor(sample(letters[1:5], 10, replace=TRUE))
for( i in unique(f) ) print(i)
x<-1:5; if(x==5) {x<-x+1} else {x<-x+2}; x
x<-1:5; ifelse(x %% 2 == 1, "Odd", "Even")
while(length(x)<=10) {x<-c(x,1)}
require(stats)
centre <- function(x, type)
{
switch(type, mean = mean(x), median = median(x), trimmed = mean(x, trim = .1))
}
x <- rcauchy(10); centre(x, "mean")
#Control de errores: traceback, browser, debug
debug(centre)
undebug()
#Control de la duración de la operación:
unix.time(centre(rnorm(10),"mean")) #unix.time, Rprof
traceback()
 
Created by Pretty R at inside-R.org