\documentclass[11pt]{book}
\usepackage{url}
\usepackage[latin1]{inputenc}
\usepackage[T1]{fontenc}
\usepackage[spanish]{babel}
\usepackage{graphicx}

\textheight 23cm \textwidth 16,5cm \topmargin 0cm
\parskip 1ex
\headsep 0,5cm \evensidemargin 0.5cm \oddsidemargin 0.5cm
\parindent 5ex
\renewcommand{\baselinestretch}{1,0}
\flushbottom

\addto\captionsspanish{\renewcommand*{\chaptername}{Tema}}

\begin{document}
\title{\Huge Introducci\'on al lenguaje R}
\author{TIplE}
\date{MAnáDINe}
\maketitle

El paquete R\footnote{Sitio de referencia:
  \texttt{http://www.r-project.org}.} es una colección de programas
libres\footnote{En el sentido GNU:
  \texttt{http://gnu.org/philosophy/free-sw.es.html}.} diseñada para
el análisis estadístico de datos, que permite desde los análisis
descriptivos más sencillos (como tablas de frecuencias simples) a
procedimientos inferenciales más complejos (como el análisis de
varianza o el análisis de componentes principales).

R realiza tres funciones esenciales: (1) leer datos, (2) especificar
el tipo de análisis que se quiere realizar con esos datos y (3)
mostrar los resultados obtenidos tras los análisis.  La interpretación
de los resultados es tarea del investigador.

\chapter*{Instalación de R}
\label{instalar}

\section*{Debian GNU/Linux}
\thispagestyle{empty} Mediante algún gestor de paquetes, solicite la
instalación de los paquetes \texttt{r-cran-rcmdr} y
\texttt{r-cran-fbasics}.  Por ejemplo, en la línea de órdenes:

\begin{verbatim}
# aptitude install r-cran-rcmdr r-cran-fbasics
\end{verbatim}

Emacs dispone de una interfaz a R llamada ESS ({\it Emacs speaks
  statistics}).  Puede instalarla mediante
\begin{verbatim}
# aptitude install ess
\end{verbatim}
y ejecutarla desde Emacs mediante \verb+M-x R+.

\section*{OpenBSD}
\thispagestyle{empty} Instale el paquete \verb+R+:
\begin{verbatim}
$ sudo pkg_add R
\end{verbatim}
y luego los paquetes de R llamados \verb+Rcmdr+ y \verb+fBasics+:
\begin{verbatim}
$ R
> install.packages(c("Rcmdr","fBasics"))
\end{verbatim}

\section*{FreeBSD}
\thispagestyle{empty} Instale el porte \verb+R+:

\begin{verbatim}
# cd /usr/ports/math/R
# make install clean
\end{verbatim}
y luego los paquetes de R llamados \verb+Rcmdr+ y \verb+fBasics+:
\begin{verbatim}
$ R
> install.packages(c("Rcmdr","fBasics"))
\end{verbatim}

\section*{ReactOS y Microsoft Windows}

Si dispone de acceso a Internet:

\begin{enumerate}

\item Descargue el fichero ejecutable
\begin{verbatim}
http://cran.es.r-project.org/bin/windows/base/R-2.8.0-win32.exe
\end{verbatim}
\item Ejecute el fichero descargado, teniendo en cuenta:
  \begin{enumerate}
  \item Cuando pregunta si deseamos establecer opciones de
    instalación, escoja \emph{Sí}.
  \item Para el modo de presentación (MDI o SDI), escoja \emph{SDI}
    (es conveniente por la implementación Tcl/Tk de Rcommander).
  \item Para la conexión a la red, escoja \emph{Internet2} (al menos,
    dentro de la Universidad Oviedo, para obtener adecuadamente la
    información sobre el proxi).
  \end{enumerate}
\item Ejecute el programa R, ya instalado.
\item En el menú \emph{Paquetes}, pinche en \emph{Seleccionar espejo CRAN}.
\item En el cuadro de diálogo, escoja \emph{Spain (Madrid)} o algún
  otro cercano, y pulse OK.
  \item En el menú \emph{Paquetes}, pinche en \emph{Instalar paquete(s)}
  \item Escoja \emph{fBasics} y \emph{Rcmdr} y acepte.

\end{enumerate}

\chapter*{Lenguaje R: tipos de objetos}

En esta sección se realiza una descripción somera de los tipos de
objetos disponibles en el lenguaje de programación R, que puede ser
útil para interpretar la información que presentan las salidas de
Rcommander.\footnote{Para profundizar más, consúltese por ejemplo
  \url{http://cran.r-project.org/doc/contrib/rdebuts_es.pdf} o
  \url{http://cran.r-project.org/doc/contrib/R-intro-1.1.0-espanol.1.pdf}.}

\section*{Tipos básicos}

Los tipos de valores básicos en R son: lógicos (booleanos), numéricos
y cadenas de caracteres.\footnote{Detallando más, hay tres tipos
  numéricos (enteros, reales [llamados también dobles o de coma
  deslizante] y complejos) y un tipo adicional \emph{crudo} para
  almacenar octetos.}  Las constantes lógicas son \verb+TRUE+
(verdadero) y \verb+FALSE+ (falso)
\begin{verbatim}
> 1 == 1
[1] TRUE
> 1 == 2
[1] FALSE
> T
[1] TRUE
> F
[1] FALSE
\end{verbatim}
Téngase en cuenta que \verb+T+ y \verb+F+ son objetos (variables del
lenguaje) que valen inicialmente \verb+TRUE+ y \verb+FALSE+
respectivamente, aunque pueden ser redefinidos.

Las constantes numéricas adoptan la notación habitual en informática;
por ejemplo, la notación exponencial o científica:
\begin{verbatim}
> 1e4
[1] 10000
\end{verbatim}
El resultado de una operación matemática puede ser \verb+Inf+
(infinito) o \verb+NaN+ (\emph{not a number}: no un número):
\begin{verbatim}
> 3/0
[1] Inf
> log(0)
[1] -Inf
> log(-1)
[1] NaN
Warning message:
In log(-1) : NaNs produced
> sqrt(-1)
[1] NaN
Warning message:
In sqrt(-1) : NaNs produced
> sqrt(-1+0i)
[1] 0+1i
> log(-1+0i)
[1] 0+3.141593i
\end{verbatim}
Nótese cómo en el ejemplo algunos \verb+NaN+es pueden evitarse usando
números complejos.

Las cadenas pueden delimitarse por comillas o por apóstrofos, lo cual
puede aprovecharse para incluir cómodamente comillas en la
cadena\footnote{Sin necesidad de \emph{escaparlas} mediante una
  retrobarra.}:
\begin{verbatim}
> "nombre"
[1] "nombre"
> 'Lo llamaban "Trinidad"'
[1] "Lo llamaban \"Trinidad\""
\end{verbatim}

Queda mencionar la constante \verb+NA+ (\emph{not available}: no
disponible) que indica un valor \emph{ausente}.  Aparece, por ejemplo,
al leer campos numéricos vacíos durante la importación de un fichero.
Al igual que \verb+NaN+, tiene comportamiento \emph{viral} (contagia):
\begin{verbatim}
> 3 + NA
[1] NA
\end{verbatim}

La asignación de valores a objetos se realiza mediante el operador
\verb+<-+\footnote{Fuera de los argumentos de funciones puede
  sustituirse por \texttt{=}, así: \texttt{a = 8.5}.}:
\begin{verbatim}
> a <- 8.5
\end{verbatim}
Pero ¡ojo!
\begin{verbatim}
> a < -3
[1] FALSE
> a<-3
> a
[1] 3
\end{verbatim}
Ten cuidado dónde pones los espacios.

Hasta ahora los valores considerados son simples; podrían llamarse
\emph{átomos} o \emph{escalares}.  En R hay también estructuras
compuestas, entre las que veremos los vectores, las matrices, las
listas y los dataframes.

\section*{Vectores}

Podemos crear un vector mediante la función \verb+c+, que concatena:
\begin{verbatim}
> b <- c(1,2,3,10)
\end{verbatim}

Los escalares en R son siempre vectores de longitud 1, así que la
asignación de \verb+a+ en la sección anterior es equivalente a:
\begin{verbatim}
> a <- c(8.5)
\end{verbatim}

Toda la aritmética en R (así como muchas de sus funciones) es
vectorial.  Por ejemplo, se pueden sumar vectores:
\begin{verbatim}
> a+b
[1]  9.5 10.5 11.5 18.5
\end{verbatim}

El \verb+[1]+ que aparece al comienzo del renglón es una ayuda para
localizar posiciones en vectores largos:
\begin{verbatim}
> 10:50
 [1] 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34
[26] 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50
\end{verbatim}
Así, el 35 ocupa la posición vigésimo-sexta.

En el ejemplo anterior se ha utilizado el operador \verb+:+ para crear
una secuencia.  La función \verb+seq+ generaliza la creación de
secuencias:
\begin{verbatim}
> seq(0,3,0.5)
[1] 0.0 0.5 1.0 1.5 2.0 2.5 3.0
\end{verbatim}

Es útil también la función \verb+rep+ para crear vectores con un
elemento repetido:
\begin{verbatim}
> rep("A",5)
[1] "A" "A" "A" "A" "A"
\end{verbatim}


Los vectores se pueden concatenar:
\begin{verbatim}
> bab <- c(b,a,b)
> bab
[1]  1.0  2.0  3.0 10.0  8.5  1.0  2.0  3.0 10.0
\end{verbatim}
pero tenga en cuenta que en un vector todos los elementos han de ser
del mismo tipo:
\begin{verbatim}
> c(bab,"cadena")
 [1] "1"      "2"      "3"      "10"     "8.5"    "1"      "2"      "3"
 [9] "10"     "cadena"
\end{verbatim}

Se puede acceder a los elementos de un vector indicando a su vez un
vector de subíndices (enteros positivos):
\begin{verbatim}
> bab[4]
[1] 10
> bab[4:6]
[1] 10.0  8.5  1.0
> bab[c(4,6)]
[1] 10 1
\end{verbatim}
Si los subíndices son negativos, indican exclusión:
\begin{verbatim}
> bab[-4]
[1]  1.0  2.0  3.0  8.5  1.0  2.0  3.0 10.0
> bab[-(4:6)]
[1]  1  2  3  2  3 10
> bab[-c(4,6)]
[1]  1.0  2.0  3.0  8.5  2.0  3.0 10.0
\end{verbatim}

Los elementos de un vector pueden tener asignados nombres.
Por ejemplo, si creamos el vector \verb+v+ mediante la
función \verb+quantile+,
\begin{verbatim}
v <- quantile (1:100, c(.25,.50,.75))
names (v)
\end{verbatim}
Se puede extraer el primer elemento de \verb+v+ mediante
alguna de las dos formas siguientes:
\begin{verbatim}
v[1]
v["25%"]
\end{verbatim}
Para quitar las etiquetas de un vector, se puede hacer de
alguna de las dos maneras siguientes:
\begin{verbatim}
v <- as.numeric(v)
names(v) <- NULL
\end{verbatim}

\section*{Matrices}

Una matriz es la versión bidimensional de un vector:
\begin{verbatim}
> m <- matrix(1:6,nrow=2)
> m
     [,1] [,2] [,3]
[1,]    1    3    5
[2,]    2    4    6
\end{verbatim}
Para obtener una submatriz, hay que indicar subíndices para filas y
columnas; en blanco, para seleccionar toda la dimensión:
\begin{verbatim}
> m[1,2]
[1] 3
> m[1,]
[1] 1 3 5
> m[,2]
[1] 3 4
>  m[,2:3]
     [,1] [,2]
[1,]    3    5
[2,]    4    6
> m[,-1]
     [,1] [,2]
[1,]    3    5
[2,]    4    6
\end{verbatim}
Obsérvese que al extraer una fila o columna el resultado es un 
vector.  Si se quiere conservar el carácter de matriz, puede 
hacerse así:
\begin{verbatim}
> m[,2,drop=FALSE]
\end{verbatim}

Se pueden pegar vectores o matrices por columnas mediante la función
\verb+cbind+ para formar una nueva matriz:
\begin{verbatim}
> cbind(1:3,c(8,9,10))
     [,1] [,2]
[1,]    1    8
[2,]    2    9
[3,]    3   10
> cbind(m,c(100,200))
     [,1] [,2] [,3] [,4]
[1,]    1    3    5  100
[2,]    2    4    6  200
\end{verbatim}
o por filas mediante la función \verb+rbind+:
\begin{verbatim}
> rbind(1:3,c(8,9,10))
     [,1] [,2] [,3]
[1,]    1    2    3
[2,]    8    9   10
\end{verbatim}

Se puede trasponer una matriz con la función \verb+t+, hallar su
determinante mediante \verb+det+, su inversa mediante \verb+solve+,
multiplicarla con \verb+%*%+, etcétera.

Al igual que los vectores, todos los elementos de una matriz han de
ser del mismo tipo (homogéneos):
\begin{verbatim}
> m[1,1] <- "nombre"
> m
     [,1]     [,2] [,3]
[1,] "nombre" "3"  "5"
[2,] "2"      "4"  "6"
\end{verbatim}

Se puede asignar un nombre a la dimensión de filas y 
otro a la dimensión de columnas, y a cada fila y columna, así:
\begin{verbatim}
dimnames (m) <- list (sujetos   = c ("Juana", "Pepe"), 
                      variables = c ("altura", "peso", "sexo"))
\end{verbatim}
Se pueden extraer mediante \verb+rownames(m)+ y \verb+colnames+.

A veces, tales nombres aparecen automáticamente:
\begin{verbatim}
pesos   <- c (80, 75, 68, 97)
alturas <- c (120, 150, 185, 172)
datos   <- cbind (pesos, alturas)
datos [, "alturas"]
\end{verbatim}
Como en el caso de los vectores, se pueden usar las etiquetas
en vez de los índices para seleccionar parte de la matriz.

\section*{Listas}

Para almacenar elementos heterogéneos hay que recurrir a una lista:
\begin{verbatim}
> l <- list(bab,"cadena")
> l
[[1]]
[1]  1.0  2.0  3.0 10.0  8.5  1.0  2.0  3.0 10.0

[[2]]
[1] "cadena"
\end{verbatim}

Al subindicar con corchetes simples se obtiene una sublista:
\begin{verbatim}
> l[1]
[[1]]
[1]  1.0  2.0  3.0 10.0  8.5  1.0  2.0  3.0 10.0
\end{verbatim}
Como en el caso de los vectores, los corchetes simples permiten 
extraer más de un elemento: por ejemplo, \verb+l[1:2]+

Al subindicar con corchetes dobles se puede extraer UN elemento de la
lista\footnote{Los vectores también pueden subindicarse con corchetes dobles.
Por comodidad, con vectores suelen usarse siempre corchetes simples porque 
todo escalar es un vector de tamaño uno (por lo que es exactamente
 lo mismo un elemento de un vector
que un subvector de longitud uno).}:
\begin{verbatim}
> l[[1]]
[1]  1.0  2.0  3.0 10.0  8.5  1.0  2.0  3.0 10.0
> l[[1]][4:6]
[1] 10.0  8.5  1.0
\end{verbatim}
Los corchetes dobles no permiten extraer más de un elemento

Los elementos de una lista pueden tener etiquetas, como en los vectores.
En el caso de 
las listas, las etiquetas se pueden usar como \verb+lista[["etiqueta"]]+
o como \verb+lista$etiqueta+:
\begin{verbatim}
> n <- list(bab=bab,cadena="Cadena")
> n[[1]]
[1]  1.0  2.0  3.0 10.0  8.5  1.0  2.0  3.0 10.0
> n$bab
[1]  1.0  2.0  3.0 10.0  8.5  1.0  2.0  3.0 10.0
> n$cadena
[1] "Cadena"
\end{verbatim}

\section*{Dataframes}

Un dataframe es una lista cuyos elementos son vectores, todos de igual
longitud.  Por tanto, se le pueden aplicar los operadores de listas y
los de matrices.  Es la estructura esencial para guardar valores de
variables estadísticas:
\begin{verbatim}
> d <- data.frame(v1=c(2,4,8,9),v2=c("v","v","m","m"))
> d
  v1 v2
1  2  v
2  4  v
3  8  m
4  9  m
> d[1,2]
[1] v
Levels: m v
> d[1,]
  v1 v2
1  1  v
> d[,2]
[1] v v m m
Levels: m v
> d$v1
[1] 2 4 8 9
> d$v2
[1] v v m m
Levels: m v
\end{verbatim}
Nótese que, al construir el dataframe, el vector de cadenas se ha
convertido en ``factor'', es decir, en un vector acompañado de una
lista de ``niveles'' (modalidades de la variable estadística).

\section*{Funciones}

Un objeto de R también puede almacenar una función:
\begin{verbatim}
> f <- function (x) x^2
\end{verbatim}
que puede usarse como argumento de otras funciones
\begin{verbatim}
> sapply (5:10, sqrt)
[1] 2.236068 2.449490 2.645751 2.828427 3.000000 3.162278
> sapply (5:10, f)
[1]  25  36  49  64  81 100
\end{verbatim}

Como se ve, la función \texttt{sapply} aplica una función a cada
elemento de un vector, y devuelve un vector de resultados.  La función
\verb+apply+ hace lo mismo con matrices, bien por filas:
\begin{verbatim}
> m <- matrix(1:6,nrow=2)
> m
     [,1] [,2] [,3]
[1,]    1    3    5
[2,]    2    4    6
> apply(m,1,sum)
[1]  9 12
\end{verbatim}
bien por columnas:
\begin{verbatim}
> apply(m,2,sum)
[1]  3  7 11
\end{verbatim}
Téngase en cuenta que \verb+sum+ es una función que calcula la suma de
un vector.

\end{document}
