R primeros pasos by Our Utopy

Computational Intelligence for Financial Methods

Artículo núm 9.1

R Project, primeros pasos Data Mining y Neural Net basados en R

Escrito por:

Colaboradores:

Miguel Pérez Fontenla

Darío Lanza Vidal, Diseño e Imagen.

Febrero, 2015

R Project, primeros pasos Data Mining y Neural Net basados en R

COPYLEFT Este material así como los applets, powerpoints, videos y archivos de sonido asociados, puede ser distribuido bajo los términos y condiciones definidos en Open Publication License versión 1.0 o posterior (La versión más reciente está disponible en http://www.opencontent.org/openpu b/). El contenido está sujeto a constantes cambios sin previo aviso. Su fin es didáctico y solo pretende la universalización de la cultura. Está escrito en base a la colaboración del equipo que compone Financial Methods. Se ha exigido a los autores que, en lo posible, referencien todas las fuentes utilizadas y que figuren en el texto. Cualquier distribución del mismo debe mencionar a Financial Methods como fuente.

Aportan y colaboran Grupo Financial Methods Nicolás Deconté Demarsy Teo Ramirez Iván Jiménez M PI asesores AEFI VisualChart Javier Inoges Alvaro Lanza Vidal Perfecto García Vila Antonio Veiga Vidal Elba Pérez Vidal Cristina Pedreira Vidal Emilio Pedreira Vidal Amando de Diego Espiñeira Cristina Simón Marco Mercedes López de Andujar Silvia Moreno Rapa Angel Leira Parrado Juan Zalvidea

INDICE AUTORES Iniciado por Miguel Pérez Fontenla ourutopy@gmail.com

TABLA DE CONTENIDO

INTRODUCCIÓN R es, básicamente, un lenguaje que permite implementar técnicas estadísticas. Es, a la vez: •

un entorno interactivo para el análisis estadístico y gráfico,

•

y un lenguaje de programación interpretado de alto nivel con funciones orientadas a objetos.

El diseño de R vino muy influenciado por dos lenguajes existentes: S (Becker, Chambers and Wilks) and Scheme (Sussman) donde S proviene de Statistics.. El resultado es un lenguaje de apariencia similar a S, pero en el que la implementación y semántica subyacente se derivan de Scheme. Es unproyecto GNU. Por lo tanto, los usuarios son libres de modificarlo y extenderlo. Se trata de un lenguaje basado en comandos, en lugar de pinchar y arrastrar iconos o menús con el ratón se escriben comandos o instrucciones que son ejecutados. Una sucesión de instrucciones o comandos de R que implementa un flujo de trabajo para realizar una tarea se denomina script o guión R. Existe una amplia variedad de entornos de desarrollo para R que facilitan escribir scripts de R tales como R commander, RKWard y RStudio. En este tutorial utilizaremos RStudio. R cuenta con una comunidad muy activa y dinámica , está bien documentado y dispone de foros de ayuda.

¿Porqué debería cambiar a R cuando ya tengo bastante conocimiento de otros programas estadísticos? Hasta la aparición de R, los matemáticos y científicops en general que usaban estadística en sus investigaciones se veían en la necesidad de crear sus propios programas o recurrir a paquetes comerciales como SPSS, Minitab, Statistica, Statgraphics, Matlab etc. Desde la disponibilidad de R y salvado el escollo de su aprendizaje, la práctica totalida de la comunidad científica se ha pasado a R y están disponibles más de 6000 apps (a fecha de hoy Marzo de 2015) o extensiones en el repositorio del programa. Si únicamente vamos a utilizar unos cuantos test estadísticos, y no pensamos hacer nada más en el futuro, quizá no valga la pena el esfuerzo. Pero hay muchos motivos para aprender su uso...

Flexibilidad: R está concebido como entorno de programación con multitud de comandos y funciones específicas en estadística que permite fácilmente implementar y evaluar técnicas nuevas. Sacar provecho de su gran cobertura (no tiene rival) y la gran disponibilidad de aplicaciones de vanguardia en infinidad de campos. Entender la literatura más actual. Cada vez más gente presenta sus resultados en el contexto de R. Basta mirar cualquier disciplina y ver quien está utilizando R: la mayoría de los profesores de cada área ya se ha cambiado. Aun más: CONTRIBUYEN y COMPARTEN. La distribución de R viene acompañada de un extenso conjunto de funciones (librería base). Adicionalmente, existen a libre disposición numerosas librerías específicas con todas las últimas técnicas disponibles (y además con explicación de su uso). Enorme calidad del apoyo y soporte disponible. Siempre encontrarás en los foros de R personas d egran capacidad dispuesta a ayudarte en cuanta duda se te plantee La comunidad de R es muy dinámica, con gran crecimiento del número de paquetes, e integrada por estadísticos de gran renombre (ejemplos, J. Chambers, L. Terney, B. Ripley, D. Bates, etc.).

El hecho que R sea un lenguaje de programación podría desanimar a muchos usuarios que piensan que no tienen alma de programadores. Nada más lejos de la realidad: •

R es un lenguaje interpretado (como Java) y no compilado (como C, Fortran, Pascal, etc.), es decir, los comandos escritos en el teclado son ejecutados directamente sin necesidad de construir ejecutables.

•

Además la sintaxis es simple e intuitiva.

•

Es efectivo, e incluye las estructuras de control típicas de cualquier lenguaje de programación, así como funciones recursivas y grandes facilidades para input y aoutput de datos y resultados.

La estructura y facilidad de uso de R nos permite implementar nuestras propias funciones y rutinas a medida que aparecen nuestras necesidades. Puede realizar gráficos de alta calidad de enorme utilidad en los trabajos de investigación (papers) Rstudio y Rcommander lo convierten también en una herramienta muy útil para la docencia. Hay extensiones específicas a nuevas áreas como bio-informática, geo-estadística y modelos gráficos. La incorporación dconstante de nuevos métodos lo convierten en uno de los entornos de programación más dinámicos existentes, lo cual tiene algunas deventajas. La más llamativa para mi es que tanto dinamismo hace que el código antiguo vaya, enseguida, quedando obsoleto y funcione defectuosamente con nuevas versiones.

Y, muy a tener en cuenta, es GRATIS. Uno de los mejores software integrados en el mundo y resulta que es nuestro a cambio de nada. En todo caso se te pedirĂa que ayudes a comunicarlo a estandarizarlo y a apoyar a los que estĂĄn empezando.

HISTORIA R es un conjunto de programas integrados para •

manejo de datos,

•

simulaciones,

•

cálculos y

•

realización de gráficos.

Es además un lenguaje de programación orientado a objetos. La raiz de R es el lenguaje S desarrollado por John Chambers y sus colegas (Becker et al., 1988, Chambers and Hastie, 1992, Chambers, 1998) en los Bell Laboratories (últimamente AT&T, ahora propiedad de Lucent Technologies) y se comenzó en 1960s. El lenguaje de programación S fue diseñado y desarrollado orientado a tareas de análisis de datos pero de hecho es un completo lenguaje de programación dotado de miles de complementos El proyecto R fue iniciado por Robert Gentleman y Ross Ihaka (de donde se deriva “R”) del Statistics Department, University of Auckland (Nueva Zelanda), en 1995. R es, pues, una implementación libre, independiente, código abierto (open-source) del lenguaje de programación S que actualmente es un producto comercial llamado S-PLUS y es distribuido por Insightful Corporation. R, originalmente, fue un programa para el sistema operativo Unix, R ahora puede obenerse también en versiones para Windows y Macintosh y Linux. A pesar de que hay diferencias menores entre R y S-PLUS (la mayoría en la interfase gráfica), son esencialmente idénticos. El desarrollo de R project para estadística está fuertemente influenciado por la idea de código abierto. La base del código fuente de R y de miles de sus extensiones están disponibles bajo los términos de Free Software Foundation’s GNU General Public License. Este tipo de licencia tiene dos principales implicaciones para todos aquellos analistas de datos que trabajan con R. Una, que al ser código abierto se pueden hacer modificaciones para adaptar cada estudio a sus pormenores específicos y que éstos se pueden distribuir a sus colegas de trabajo. Como un efecto colateral el sistema R para estadística computacional está disponible para todos. Todos los científicos, incluyendo a aquellos que trabajan en países en vias de desarrollo, tienen acceso a todas estas herramientas sin ningún coste. Así pues , cualquier avance en investigación queda ahora disponible no solo a través del documento o estudio convencional sino que los datos, los pasos realizados y los análisis computacionales ejecutados quedan incluidos en el R transcript file del trabajo. R es en la actualidad ampliamente usado para enseñanza estadística en High Schools, Universiodades y post graduadois en todo el mundo. Acualmente R es mantenido y distribuido por un pequeño grupo internacional de estadísticos y desarrolladores voluntarios: el R Core Development Core Team, para el análisis y comprensión de datos de genómica, especialmente microarreglos, y se inició a mediados de 2001. Una inmensa cantidad de nuevas funcionalidades se están añadiendo constantemente 7

como paquetes add-on autorizados y mantenidos por un gran grupo de personas desinteresadas y voluntariamente para tal cometido. ( http://www.bioconductor.org/whatisit ) La página web del proyecto R es http://www.r-project.org. Este es el sitio principal sobre información de R: documentación, FAQs (FAQ son las iniciales de Frequently Asked Questions, o sea preguntas más frecuentes). Para bajar el sofware directamente se puede visitar el Comprehensive R Archive Network (CRAN): http://cran.us.r-project.org/ La versión actual de R, en Marzo de 2015, es la 3.1.2 Para analizar los datos de microarreglos utilizaremos el software R y programas específicos desarrollados por BioConductor. Este también está integrado por Análisis Exploratorio y Confirmatorio de Datos de Experimentos de Microarrays TP 1 Dpto. de Matemática - Instituto de Cálculo 1er. Cuatr. 2006 Dra. Diana M. Kelmansky 2 Las funciones de R se agrupan en paquetes (packages, libraries), los que contienen las funciones más habituales se incluyen por defecto en la distribución de R, y el resto se encuentran disponibles en la Comprehensive R Archive Network (CRAN) http://cran.rproject.org R y S-Plus aún comparten una gran mayoría de código e instrucciones, pero probablemente serán dos entornos independientes en un futuro a medio plazo. Resumiendo •

Precio: R gratuito, S-Plus comercial

•

S-Plus es más "amigable": funcionalidad por menús (limitada)

•

R se ejecuta exclusivamente mediante el envío de instrucciones en la línea de comandos: curva de aprendizaje más lenta, aunque más versatilidad

•

R dispone de una comunidad de desarrolladores/usuarios detrás que se dedican constantemente a la mejora y a la ampliación de las funcionalidades y capacidades del programa. Nosotros mismos podemos ser desarrolladores de R!!

•

Disponible en la red a través del Comprehensive R Archive Network (CRAN). La dirección en internet es http://cran.r-project.org/.

La experiencia de Ross and Robert en el diseño e implementación del lenguaje está descrito en Ihaka and Gentleman (1996), R: A Language for Data Analysis and Graphics, Journal of Computational and Graphical Statistics, 5, 299-314. La importancia de este lenguaje es tal que existen dos congresos (useR -anual- y DSC -bianual) enteramente dedicados a su uso. Hasta en el New York Times se ha escrito sobre las excelencias de R: http://www.nytimes.com/2009/01/07/technology/business-computing/07program.html?_r=2

Desde 2009 existe una publicación The R Journal enteramente dedicada a artículos sobre el desarrollo y la aplicación de R.

Anécdotas y curiosidades sobre R La experiencia de Ross and Robert en el diseño e implementación del lenguaje está descrito en Ihaka and Gentleman (1996), R: A Language for Data Analysis and Graphics, Journal of Computational and Graphical Statistics, 5, 299-314. La importancia de este lenguaje es tal que existen dos congresos (useR -anual- y DSC -bianual) enteramente dedicados a su uso. Hasta en el New York Times se ha escrito sobre las excelencias de R: http://www.nytimes.com/2009/01/07/technology/business-computing/07program.html?_r=2 Desde 2009 existe una publicación The R Journal enteramente dedicada a artículos sobre el desarrollo y la aplicación de R.

COMO INSTALAR R Para instalar R hay que bajar un fichero ejecutable de la página web del proyecto R: http://www.r-project.org/ Para Microsoft Windows: bajar ("download") el ejecutable desde http://cran.r-project.org/bin/windows/base. En esta página debemos hacer clic en download CRAN, escoger a continuación uno de los servidores (CRAN Mirrors) y después seguir los pasos según el sistema operativo. Actualmente (Febrero 2015), la versión más reciente de R para el entorno Windows es la 3.1.2 y el ejecutable de tamaño aproximadamente 55,586 Kb tiene el nombre R-3.1.2-win.exe Una vez bajado este ejecutable, hay que ejecutarlo y seguir las instrucciones del programa de instalación. Tarea: Instalar la última versión de R tras desinstalar cualquier versión previa que pudiera haber en el ordenador de trabajo. RStudio se puede descargar en http://www.cs.us.es/

Aparte del propio R se hace imprescindible instalar las bibliotecas de funciones •

Rexcel , desde http://rcom.univie.ac.at/ que permitirá el uso conjunto de la hoja de cálculo Excel de Microsoft con R.

•

R-Commander , que se instala desde la barra de menús -> paquetes

Actualizaciones R es, como quien dice, un organismo vivo que está en contínua mejora por los miles de personas desinteresadas que se dedican a mejorarlo. Ello implica una continua y constante avalancha de actualizaciones y mejoras que hay que estar instalando si queremos estar al día. No olvidemos que R tiene problemas u errores que se van solucionando en versiones posteriores. No creas que esto es una obviedad. Se da mucha casuística con las bibliotecas que se diseñaron en una versión concreta que luego no funcionan o dan problemas en la siguiente. R es código libre y gratuito asi que no se te ocurra protestar, que nadie cobra por trabajar en este magnífico proyecto.

En general, hay dos maneras sencillas y básicas de instalar una actualización 1. Ir al Panel de Control, desinstalar la actual versión de R, descargar la nueva versión e instalarla, fin. 2. Otra seria ejecutar el comando, siempre teniendo cuidado de salvar tu librería personal si la tuvieses > update.packages(checkBuilt=TRUE, ask=FALSE)

Para facilitar las labores de instalar nuevas versiones se han publicado utilidades que facilitan los procesos. El installr es un paquete que realiza el proceso de actualización http://cran.r-project.org/web/packages/installr/index.html Otro paquete que cumple esa función es: "miniCRAN". http://cran.r-project.org/web/packages/miniCRAN/index.html Ha sido noticia últimamente el paquete checkpoint, que te permite ocupar versiones de paquetes para fechas precisas de manera tan sencilla como añadir al programa: checkpoint("2015-03-24") [para la fecha de hoy, por ejemplo]. http://cran.r-project.org/web/packages/checkpoint/index.html

SCRIPTS Para operaciones que requieran varias instrucciones consecutivas, resulta especialmente útil el trabajar con un fichero de comandos editable (script). El mantenimiento del código ordenado y comentado es "una buena práctica estadística". R proporciona por defecto la posibilidad de trabajar con scripts como ventanas del propio programa. Podemos abrir un script nuevo desde el menú Archivo/Nuevo script. Desde ellos, podemos ejecutar con CTRL + r los comandos de la línea en la que estamos, o el bloque de comandos que tengamos seleccionado. Conviene guardar el fichero para su posterior uso.

Instalación de editores en Windows Hay editores de R que hacen la vida más amigable al usuario. Entre los editores de texto e IDEs con soporte para R se cuentan: • • • • • • • • • • • • • • • • • • • •

Rcommander RWinEdit, Tinn-R, RStudio, (*****) Bluefish, Crimson Editor, ConTEXT, Eclipse, Emacs (Emacs Speaks Statistics), Geany, jEdit, Kate, RKWard, Syn, TextMate, Vim, gedit, SciTE, WinEdt (R Package RWinEdt) y Notepad++

Sweave es un procesador de documentos que puede ejecutar código de R incrustado en código de LaTeX y para insertar código, resultados y gráficos en el documento escrito en LaTeX. LyX puede usarse para crear y compilar documentos desarrollados en Sweave. El paquete odfWeave es similar, generando documentos en el formato OpenDocument (ODF); extensiones en estado experimental también permiten generar documentos del tipo presentación u hoja de cálculo.

El Rcommander El R-Commander es un paquete adicional de R que facilita los cálculos estadísticos y posee la interfaz gráfica integrada. Para descargar R y R-Commander http://knuth.uca.es/R/R-UCA

a la vez, lo puedes hacer en el siguiente enlace:

Le dedicaremos un párrafo especial más adelante

Editor RWinEdt RWinEdt es un editor para scripts disponible para usuarios de R en el sistema de operativo Windows. Requiere que el editor WinEdt (programa de pago) esté instalado en el ordenador. Disponible en http://www.winedt.com Entonces es posible instalar la librería RWinEdt y abrir el editor mediante library(RWinEdt). En RWinEdt se pueden abrir y editar diferentes scripts y enviarlos a ejecución en R. La ventaja de este editor sobre los scripts en R, es que ofrece una serie de opciones no existentes en R, entre otras, por ejemplo, comprobar rápidamente que ningún paréntesis queda sin cerrarse o marcar, copiar y pegar columnas.

Editor TinnR Otra alternativa es utilizar el editor TinnR (acrónimo de Tinn is not notepad) que es similar al anterior pero de libre distribución. Está disponible en http://www.sciviews.org/Tinn-R/ La versión más reciente compatible con el modo MDI de R gui es la 1.17.2.4 y el ejecutable tiene el nombre Tinn-R_1.17.2.4_setup.exe. Actualmente (marzo 2011) la versión más reciente (ya sólo compatible con el modo SDI) es la 2.3.5.2 y el ejecutable tiene el nombre Tinn-R_2.3.7.1_setup.exe. Para configurar como lanzar el código seleccionado (líneas, párrafos, etc.) desde Tinn-R hasta R debemos indicar la combinación de teclas con las que queremos que se lance el código entrando en el menú R > Hotkeys of R, por ejemplo, con CTRL + Tabulador o CTRL + r, podemos pedir que lance un bloque o una línea. Las versiones más actuales de Tinn-R requiere que R gui se ejecute en modo SDI (por defecto está en modo MDI). Para realizar este cambio debemos abrir el programa R y luego entrar en el menú Editar > Preferencias de la interfaz gráfica..., en el que podremos realizar dicho cambio al modo SDI. Para que tenga efecto grabamos el fichero resultante. Si queremos que cuando acabe de ejecutar los comandos en R se quede en la ventana del programa R debemos indicarlo desde el menú de Tinn-R Options > Return focus after sending 13

to R o bien mantener sin pulsar la pestaña correspondiente (una con una fecha azul y otra roja). Para utilizarlo con Windows Vista y Windows 7 es necesario cambiar un archivo de inicialización del sistema denominado Rprofile. Tarea: Instalar Tinn-R y prepararlo para su uso.

Editor RStudio RStudio es otro editor de scripts que está colocándose en el número uno como preferido entre los usuarios R-adictos, disponible en todos los sistemas operativos. Los autores lo consideran un entorno de desarrollo integrado que combina un interfaz muy intuitiva con herramientas de código muy potentes que permiten sacar el máximo provecho a R. La versión en pruebas es gratuita y está disponible en

http://www.rstudio.org/ Como los anteriores la ventaja de este editor es que ofrece una serie de opciones no existentes en R, entre otras, por ejemplo, comprobar rápidamente que ningún paréntesis queda sin cerrarse o marcar, copiar y pegar columnas. Pero además nos da un listado de las variables y nos da una descripción de los bancos de datos que hemos introducido. También tiene una lista de los paquetes instalados y los gráficos realizados. En principio, en el grupo FinancialMeth será el editor que usaremos por defecto.

Ejemplo de script que importa datos de Yahoo Finance El siguiente script leee de Yahoo.finance los datos históricos de amadeus y realiza un gráfico read.table ( "http://ichart.yahoo.com/table.csv?s=TEF.MC&a=0&b=2&c=2015&d=2&e=19&f=2015&g=d&ig nore=.csv" , header = TRUE, sep = "," # .................................................................................. # Leemos de Yahoo el Ticker AMS.MC # cotizaciones en CSV desde enero/2010 hasta 19/Feb/2015 # conteniendo cabecera y con separador "," # .................................................................................. amadeus_data <- read.table ( "http://ichart.yahoo.com/table.csv?s=AMS.MC&a=0&b=1&c=2010&d=2&e=19&f=2015&g=d&i gnore=.csv" , header = TRUE, sep = "," ) # .................................................................................. # Local alternative after getting it from CURL or Browser # Suppose for instance that we use Dates as row names: # amadeus_data <- read.table("/Users/nico/Documents/StockData/Amadeus_Data.csv", header=TRUE, row.names=1, sep=",") # .................................................................................. # Ordeno el DataFrame por la Columna "Date" # .................................................................................. amadeus_data <- amadeus_data[order(amadeus_data$Date),] head(amadeus_data) # .................................................................................. # Establecemos un grafico de 3 filas y 1 columna # donde el gráfico 1 (precios) tomará las 2 primeras filas # y el grafico 2 (volumen) tomará la fila 3 # .................................................................................. layout(m,3,1,respect=TRUE) m <- matrix(c(1,1,2)) # Escribimos el gráfico de precios amadeus en la zona 1 plot(amadeus_data$Close,ylab="Price",type="l",xaxt='n',xlab="",xaxs="i",mar=c(0.1,1,0.1,1)) # Y en el dibujo 2, hacemos un gráfico de barras (barplot) con la variable volumen: barplot(amadeus_data$Volume,names.arg=amadeus_data$Date,xaxs="i",omi=c(0.1,1,0.1,1))

1 2 3 4 5 6 7 8 9

Date Open High Low Close Volume Adj.Close 2015-03-18 38.49 38.49 38.06 38.22 1745800 38.22 2015-03-17 38.49 38.76 38.06 38.33 1040700 38.33 2015-03-16 38.31 38.69 38.30 38.38 1190900 38.38 2015-03-13 38.01 38.33 37.85 38.24 1756400 38.24 2015-03-12 37.89 38.22 37.71 37.79 14676300 37.79 2015-03-11 37.81 38.23 37.69 38.01 1176300 38.01 2015-03-10 37.69 38.35 37.45 37.54 4127400 37.54 2015-03-09 37.88 37.94 37.28 37.55 1270600 37.55 2015-03-06 38.10 38.42 37.98 38.08 2286700 38.08 15

10 2015-03-05 37.52 38.37 37.41 38.02 1687600 38.02 11 2015-03-04 36.76 37.58 36.42 37.43 1940000 37.43 12 2015-03-03 36.86 37.25 36.81 36.88 3763400 36.88 13 2015-03-02 37.19 37.34 36.31 36.86 1978200 36.86 ...................................................................................... ...................................................................................... ...................................................................................... 1269 2010-05-03 11.67 12.00 11.50 11.80 1819900 10.68 1270 2010-04-30 12.00 12.68 11.75 12.00 6160900 10.86 1271 2010-04-29 11.00 12.00 11.00 11.90 41145400 10.77

Gracias Nico!

COMO FUNCIONA R

Una vez instalado, podemos ya ejecutar el programa. Para ello, sólo hace falta hacer click en el icono o desde el menú de programas seleccionar el icono correspondiente. Lo primero que aparece en la cabecera es la versión que estamos utilizando. Conviene visitar habitualmente la página del proyecto para ver si hay una nueva versión. Si la hay y la queremos instalar, es recomendable que desinstalemos la anterior previamente. Tal y como aparece en el primer menú, R es un software libre y viene sin GARANTIA ALGUNA, aunque es posible redistribuirlo bajo ciertas circunstancias. Más info tecleando el comando license(). Mediante citation() podemos saber cómo citar R o paquetes de R en publicaciones y así dar el crédito a la enorme cantidad de personas que desarrollan este proyecto. En el modo por defecto, abriendo R se abre una sola ventana, la vconsola o ventana de comandos de R en la cual introduciremos los comandos y será dónde se verán los resultados de los análisis. Justo después de la cabecera, aparece una línea en blanco con el símbolo > en el margen izquierdo: PROMPT. R utiliza línea de comandos, como los intérpretes de programación antiguos, en lugar de ventanas de Windows o interface gráfico. Para muchos esto es una ventaja y otra otros tantos muchos es un inconveniente. Les suele gustar a los programadores entrados en años, porque resulta más fácil detectar errores de sintaxis y programación, aparte que tras cada iunstrucción se obtiene un resultado, pero son simples gustos. Tras aparecer el PROMPT, R espera que escribamos COMANDOS e instrucciones para comenzar a trabajar. 17

Para ejecutar un comando escrito utilizamos la tecla de intro. Las óhelp() rdenes elementales consisten en expresiones o en asignaciones: •

Si una orden consiste en una expresión, se evalúa, se imprime y su valor se pierde.

•

Una asignación, por el contrario, evalúa una expresión, no la imprime y guarda su valor en una variable.

En cada línea sólo caben 128 caracteres: si queremos escribir más, podemos utilizar otra línea que comienza con el símbolo + en el lado izquierdo de la pantalla en vez de >. Esto también puede ocurrir cuando el comando que terminamos de escribir no está completo (falta un paréntesis, etc.). Si encontramos que el error es la falta de algo podemos teclearlo, y al pulsar intro, ejecutará lo que hayamos solicitado. Para separar expresiones se emplea ; (punto y coma). R se compenetra muy bien con LaTeX, el editor de texto especializado en formatos matemáticos. Con ambos en equipos e pueden conseguir documentos de muy buena calidad estética. Tanto es así que la comunidad científica los están convirtiendo en un estandar para presentar sus trabajos de investigación y colocarlos ebn el repositoriod e R.

Cosas de principiante muy a tener en cuenta •

R distingue mayúsculas y minúsculas.

•

Para asignar valores siempre usaste el signo "=" y ahora también lo puedes hacer pero te aconsejamos isar los dos signos "<-"

•

Para ver el contenido de un objeto simplemente escribimos su nombre.

•

Para

usar

los

comandos

escribimos

nombre

del

comando

seguido

sus

argumentos entre paréntesis. Por ejemplo, ls( ) da una lista de los objetos en el área de trabajo. Como no usamos argumentos (diferentes a los que el comando tenga por defecto) no escribimos nada en el paréntesis. •

Para

obtener

ayuda

usamos

comando help

altertivo

"?".

Por

ejemplo, help(mean) o ?mean para obtener ayuda sobre el comando mean que calcula la media. •

El comando c se usa para combinar varios objetos en uno solo. Por ejemplo:

A <- 5 a <- 5 x <- c(3, 5, 10) x

Asigna el valor 5 a la variable A Asigna el valor 5 a la variable a, distinta de la A Crea por asignación el vector x = (3, 5, 10) Expresa en pantalla el valor de x en consola [1] 3 5 10 18

Calcula y expresa en pantalla la media de x [1] 6 Se pueden escribir dos o más órdenes o asignaciones en un mismo renglón separándolas por ";" Se puede continuar una expresión de un renglón en el renglón siguiente escribiendo un + al principìo del renglón. Así, en este ejemplo, equivale a 'a <- 5'

mean(x) >

a <- 5 ; b <- 10

> a <+ 5

Comandos rápidos en R ESC > getwd ( ) > setwd (directory) > CTR + "L" > CTR + "C" ; , + > q( ) " ! # > demo( ) > help () >? > help(mean) > help(regression) > help.search("regression") > ?regression > ??regression > source() > source("comandos.R") > savehsitory( ) > loadhistory( ) > options( )

> options(digits=2) > rm( ) > rm(list=ls())

Vuelve aparecer el prompt > Get work directory, nos dice el directorio de trabajo actual [1] "C:/Users/SW/Documents" Establece un nuevo directorio de trabajo Limpia pantalla

Interrumpe ejecución en curso Separa ordenes en la misma linea Separa argumentos entre paréntesis Orden incompleta ... continuación es el comando para salir de R. Recuperamos instrucciones utilizadas en la sesión Podemos corregir errores indica la introducción de un comentario. permite realizar demostraciones del uso de R. Inicia el servidor de ayuda Equivale a help Visualiza la ayuda referente a todo lo disponible respecto a mean No encuentra ningún comando regression pero.... Busca dentro de la ayuda aquellos lugares en los que aperece la palabra regresión Sigue sin saber nada Equivale a help.search Ejecuta todos los comandos guardados en un script Salva la historia actual Carga una historia previamente guardada Para ver y modificar opciones generales del programa durante la sesion. Tiene decenas de variable. Consultar ayuda para ampliar. Una de las que más me interesan es el númerod e decimales en pantalla # Establece 2 cifras decimales significativas Borra objetos Borra todos los objetos

Fecha y hora del sistema > date() Sys.time() Sys.Date()

Nos devuelve la fecha del sistema completa [1] "Sat Mar 28 18:12:37 2015" Bos devuelve la Fecha y hora de este instante en el sistema [1] "2015-03-28 18:10:36 CET" Nos devuelve la fecha del sistema [1] "2015-03-28" 19

Ordenación De Carpetas Para R R genera mucha información de salida (outputs). Esto conlleva que hay que ser extraordinariamente ordenado con los documentos que obtengamos para no crear un oceano de información. Es aconsejable pues crear directorios específicos en nuestro dispositivo de almacenamiento para los distointos tipos de objetos o archivos •

datos, con constituye la materia prima o información que suministramos a R

•

scripts, que son los códigos de R que hemos utilizado con sus explicaciones que puede ser utilizado más adelante y puede ser enviado a otros investigadores para su colaboración.Los scripts pueden ser editados con cualquier editor de texto

•

imagenes, o fotografías de lo que, un momento dado, está activo en R

•

historias, o conjunto de todos los comandos que hemos utilizado

•

gráficos,

•

anotaciones, o explicaciones de lo que estamos haciendo

El comando source () ejecuta todos los comandos guardados en un script

Un primer contacto con R Fuente https://www.uam.es/personal_pdi/ciencias/joser/paginaR/intro.html Vamos a realizar una primera práctica muy básica que nos ayude a familizarizarnos con R y darnos una visión general, aunque repetiremos esto mismo con otras prácticas más avanzadas Daremos consejos que repetiremos posteriormente o que ya lo hemos hecho previamente. Suponemos que ya bajaste el programa y ya lo tienes instalado en tu ordenador, pero por si acaso te señalo los pasos: http://cran.es.r-project.org/

Descargar Programa en este link

A continuación la práctica consistirá en: 1. Importaremos a R un fichero con datos, 2. Usaremos algunos comandos básicos elementales. 3. Haremos algunos cálculos matemáticos sencillos, 4. Guardaremos los datos y resultados obtenidos, y finalmente 5. Escribiremos una función muy sencilla que simula el lanzamiento de un dado. 20

Para llevar a cabo esta práctica, lo más simple es copiar los comandos de R y pegarlos en la consola, y después comprobar que el resultado coincide con el que aparece aquí.

Datos Es bastante habitual encontrar datos en la web en formato de texto. Antes de poder trabajar con ellos hemos de importarlos a un formato con el que R pueda trabajar. La Comunidad de Madrid evalúa anualmente a los alumnos de sexto de primaria de todos los colegios sobre varias materias. Los datos que vamos a utilizar corresponden a las notas medias obtenidas por los colegios en los años 2009 y 2010 (fuente: diario El País) junto con el tipo de colegio (concertado, privado o público)

Bajar los datos y generar un fichero de R El comando read.table lee un fichero de datos de texto y crea un fichero con 873 registros con el que R ya puede trabajar. notas <- read.table("http://www.uam.es/joser.berrendero/datos/notas.txt", sep = " ", dec = ",", header = TRUE)

•

El camino en Internet en el que se encuentra el fichero notas.txt (entre comillas).

•

El argumento sep especifica la separación entre las distintas variables. En este caso, un espacio en blanco.

•

El argumento dec especifica cómo se separa en los números la parte entera y la parte decimal. En este caso, mediante una coma.

•

El argumento header

especifica si la primera fila del fichero contiene (TRUE) o no

(FALSE) los nombres de las variables. En este caso, la primera fila sí que contiene los nombres de las variables. •

El símbolo # se usa para poner comentarios explicativos del código que escribes

Con esto hemos creado un objeto de R, llamado notas, que contiene los datos en un formato con el que R ya puede trabajar. Técnicamente, este tipo de objetos se llaman data frames.

Medidas descriptivas elementales Notas

Lista todo el dataframe notas tipo nota09 nota10 1 concertado 9.34 8.5200 2 publico 9.24 5.9600 3 concertado 9.17 5.4600 4 privado 9.14 7.9250 21

names(notas)

mean(notas$nota09)

mean(notas$nota10) sd(notas$nota09) sd(notas$nota10) summary(notas)

5 publico 9.09 6.4000 ....................................... Para ver los nombres de las variables del fichero notas, escribimos: [1] "tipo" "nota09" "nota10" Dentro de este fichero cada variable se identifica usando la sintaxis fichero$variable. Por ejemplo, las medias de las notas de 2009 y 2010 se obtienen con los comandos: [1] 6.605 [1] 5.44 Las desviaciones típicas de las notas de 2009 y 2010 se obtienen con los comandos: [1] 1.032 [1] 1.195 El comando summary permite calcular algunas medidas descriptivas elementales de todas las variables del fichero simultáneamente: tipo nota09 nota10 concertado:392 Min. :2.170 Min. : 0.000 privado : 98 1st Qu.:5.970 1st Qu.: 4.810 publico :732 Median :6.685 Median : 5.497 Mean :6.605 Mean : 5.440 3rd Qu.:7.350 3rd Qu.: 6.250 Max. :9.340 Max. :10.530

Algunos gráficos hist(notas$nota09)

Un histograma de las notas de 2009. La distribución es bastante simétrica aunque muestra una ligera asimetría a la izquierda.

Para comparar conjuntos de datos un diagrama de caja puede ser más útil que un histograma. Por ejemplo, para comparar las notas de 2009 con las de 2010:

boxplot(notas$nota09, notas$nota10)

boxplot(notas$nota10 notas$tipo)

plot(notas$nota09, notas$nota10)

Vemos que en 2010 las notas tienden a ser más bajas. También podemos comparar las notas de 2010 para cada tipo de colegio. Aunque las diferencias no son muy grandes, los centros privados tienden a tener notas más altas que los concertados, y éstos más altas que los públicos.

Para estudiar si hay relación entre las notas de los dos años podemos representar la correspondiente nube de puntos:

cov(notas$nota09, notas$nota10) cor(notas$nota09, notas$nota10)

Se observa una relación positiva moderada. Numéricamente, esta relación se puede cuantificar mediante la covarianza y la correlación: [1] 0.6504 [1] 0.5273 El valor de la correlación es moderadamente positivo, tal y como habíamos observado al mirar la nube de puntos.

Otras operaciones matemáticas curve(cos(x^2),0,2*pi)

Además de para analizar datos, R se puede usar para llevar a cabo todo tipo de representaciones gráficas y cálculos matemáticos. Por ejemplo, el comando de la izquierda representa la función $ cos (x^2) $ entre 0 y $ 2\pi $)

integrate(function(x) cos(x^2),0, pi)

La integral de la función anterior entre 0 y $ \pi $ 24

D(expression(cos(x^2)),"x")

0.5657 with absolute error < 9.5e-06 Una derivada de la función anterior

curve(dnorm(x,mean=3,sd=1), -1,7)

-(sin(x^2) * (2 * x)) Para representar la función de densidad de una variable aleatoria normal de media $ \mu=3 $ y desviación típica $ \sigma=1 $ en el intervalo [-1, 7]

x<-rnorm(1000,mean=3,sd=1) hist(x)

Hemos usado el comando dnorm, con los argumentos adecuados, para evaluar la función de densidad normal. Ahora lo que queremos es generar 1000 números aleatorios que sigan esta distribución y después representar el correspondiente histograma

Guardar los resultados y el código 25

Al entrar en R, se considera cierto directorio por defecto como el directorio de trabajo. Este directorio puede cambiarse en el menú Archivo, Cambiar dir. Resulta conveniente tener un directorio diferente para cada proyecto que realicemos. Al salir de R se nos pregunta Guardar imagen de área de trabajo?. Si respondemos afirmativamente, se crea un fichero .RData en el directorio de trabajo que contiene todos los objetos del área de trabajo en el momento de salir. Posteriormente, haciendo doble click en este fichero podremos entrar en R y seguir trabajando exactamente en el mismo punto en que lo habíamos dejado al salir. Alternativamente podemos usar los comandos save y load para guardar y recuperar objetos. Consulta la ayuda de estos comandos para ver sus diferentes opciones. Todos los comandos y código de R se pueden guardar en un fichero de texto (con extensión.R) dentro del directorio de trabajo. El comando source se puede usar para ejecutar todo el código contenido en un fichero de texto. En el menú Archivo, Abrir script podemos acceder a un editor muy simple en el que poder ir escribiendo el código.

LA AYUDA EN R R dispone de una ayuda muy completa sobre todas las funciones, procedimientos y elementos que configuran el lenguaje. Además de las opciones de menú propias de R, desde la ventana de comandos se puede acceder a información específica sobre las funciones de R con el comando help o mediante ? Help.start() help(log)

Inicia la función ayuda en el navegador Nos abre la ventana de ayuda sobre la función log.

help ls help regression

Busqueda del comando ls No encuentra nada porque R no tiene ninguna función que se llame regression Hace lo mismo para la función help

? ls > apropos( ) > example( )

Tarea: Consultar la ayuda sobre los comandos apropos() y find(). Consultar la ayuda sobre if (observar la diferencia entre ?if, help(if) y help(ïf")). Cuando no sepamos el nombre exacto del comando o de la función que necesitamos, pero sí que sepamos el tema sobre el que queremos ayuda (en inglés), podemos utilizar la función help.search(). Help.search("regression") ??regression > example("hclust") > demo(graphics)

Busca dentro de los contenidos de la ayuda aquellos comandos donde aparece la palabra regression Nos aportará dicha info. Equivale a help.search Ejecuta ejemplos de una función R incluye demostraciones de algunas de sus funcionalidades

Es posible acceder a manuales vía el menú Ayuda-Manuales (en PDF) o via CRAN: http://cran.r-project.org/ Algunos de los manuales disponibles son: •

R para principiantes traducion al español de la versión de Emmanuel Paradis, libro corto y directo, idóneo para usuarios con un buen nivel de programación en otros sistemas y que queiran adquirir una visión introductoria amplia a base de muchos ejemplos

•

An Introduction to R introduce el lenguaje, a la vez que presenta cómo utilizar R como herramienta para el análisis estadístico y gráfico. Existe una traducción de éste en español.

•

R Language Definition documenta el lenguaje per se, es decir los objetos en los que se basa y los detalles del proceso de evaluación. De gran utilidad cuando se va a programar funciones.

•

Writing R Extensions cubre cómo crear nuestras propias librerías, cómo escribir los archivos de ayuda y cómo utilizar y conectar con lenguajes externos (C, C++, Fortran, etc.).

•

R Data Import/Export describe las utilidades para importar y exportar datos en R incluyendo librerías disponibles en CRAN. Viene incorporado al paquete de distribución(Ver 3.1.3)

•

R Installation and Administration.

•

The R Reference Index (que aparece en el menú de ayuda como R Reference manual) contiene todos los ficheros de ayuda de la versión estándar de R junto con los de las librerías recomendadas en un único _chero imprimible.

•

R Internals es una guía para las estructuras internas de R.

Desde el propio programa, a través del menú Ayuda podemos ir a la página web de las FAQ. Hay dos, una más genérica R FAQ y otra para windows R for Windows FAQ. Si nos vemos muy apurados podemos intentar preguntar a alguien que ya haya pasado por los mismos problemas anteriormente. Para ello existen varias listas de correo (foros) donde preguntar dudas, aunque antes de plantear una pregunta conviene revisar antes lo que ya se ha preguntado y que por tanto ya aparece en las FAQ. Por supuesto, pertenecer a una lista permite recibir todas las dudas que allí en el foro se plantean (aunque a veces puede llegar a ser cansino recibir tantos correos). El acceso a estas listas se puede realizar desde la página web del proyecto R. La bibliografía de R es extensísima! Imposible darla toda entera. En la página web del proyecto existe disponible mucha Contributed Documentation que además es de libre distribución. Entre la enorme cantidad de libros (posiblemente en la actualidad haya más de 100!) enteramente dedicados a R destacamos únicamente dos: •

John M. Chambers (2008), Software for Data Analysis: Programming with R. Springer, New York.

•

Peter Dalgaard (2008), Introductory Statistics with R, 2nd edition. Springer.

Ejercicio Consultar la ayuda sobre los comandos apropos() y find(). Consultar la ayuda sobre if (observar la diferencia entre ?if, help(if) y help(ïf")). 28

EL ÁREA DE TRABAJO (workspace) Todos los objetos que se van creando en R se almacen en lo que se denomina área de trabajo (workspace). En cualquier momento podemos guardarlo con un nombre que elijamos (R le asigna la extensión .Rdata) y cuando queramos podemos recuperarlo. Veamos los comandos que nos facilitan estas tareas > save.image ("workspace name") >save(<objetos>,file="nombre.RData ") > ls( )

Guarda en cualquier momento el área de trabajo actual vigente mediante Guarda selectivamente

> load("workspace name")

Informa de la lista de objetos se encuentran en el workspace en un momento dado Es alternativa a la anterios ls() # segunda posición en la ‘‘search list’’ Para acceder a objetos de la carpeta de trabajo (o del camino que especifiquemos) se pueden adjuntar: recupera un workspace previamente almacenado

> rm() > q()

Elimina objetos del workspace Salir de R preguntando si quieres guardar el workspace actual

> objects() > ls(pos=2) > attach("misdatos.RData")

Archivo histórico Igualmente, todos los comandos que se van ejecutando en R quedan almacenados en la historia de R , que es un fichero en el que se guarda topdo lo que hemos escrito durante la sesión. Este fichero está siempre disponible de forma que con las flñechas del teclado arriba y abajo nos podemos mover a través de él y volver a ejecutar cualquier comando previa edición, si es necesaria. Este archivo histórico también se puede guardar en un fichero que, posteriormente, puede ser editado y guardado como un script > savehistory ("mi_historia") > getwd ()

Guarda con el nombre mi_historia el histórico actual. Volvemos a ver el directorio en uso para saber donde nos lo guardó > loadhistory("mi_historia") Carga el fihcero mi_historia, de forma que con las flechas podemos ir viendo todos los comandos que forman parte de esa historia El fichero mi_historia puede ser editado con el bloc de notas, o cualquier otro editor, ponerle comentarios, eliminar los errores y guardarlo finalmente como un script o como historia.

Permanencia de los datos y eliminación de objetos Ya hemos comentado que la colección de objetos almacenados en cada momento se denomina espacio de trabajo (workspace). Los objetos creados durante una sesión de R pueden almacenarse en un archivo para su uso posterior (archivos .RData antes comentados). Es posible eliminar objetos con el comando rm(). Desde el menú Misc>remover todos los objetos se pueden eliminar todos los objetos a la vez. 29

Como hay nombres que tendemos a repetir, es recomendable utilizar un directorio de trabajo diferente para cada problema que analicemos con R. Es posible cambiar de directorio desde el menú Archivo o con el comando setwd("C:/midir"). Si no sabemos en qué directorio estamos podemos averiguarlo con el comando getwd(). A veces nos interesa ejecutar varias órdenes que tengamos almacenadas en un archivo, p.e. ordenes.R. Si el fichero está en el directorio de trabajo, es posible ejecutarlas dentro de una sesión de R con la orden source("ordenes.R"). Esta función también está disponible en el menú Archivo.

R COMO CALCULADORA R puede ser usado como una calculadora científica convencional R es sensible a mayúsculas y minúsculas. Los comandos van siempre en minúsculas

>2+3 >2*3*4*5 >7/5 - 1 > (1 + .075)^5 > pi * 2.5^2 > aqrt(2)

Sumara 2 + 3 y aparecerá [1] 5 Realiza la multiplicación y resuelve [1] 120 Operaciones combinadas [1] 0.4 Calculo con potencias [1] 1.435629 R conoce pi y puede calcular una superficie del circulo de radio 2.5 [1] 19.63495 R contirene las funciones matemáticas elementales trascendentes y muchas otras habituales en cualquier programa científico como log(x), exp(x), log(x,n), log10(x), sqrt(x), factorial(x), choose(n,x), gamma(x), lgamma(x), floor(x), ceiling(x), trunc(x), round(x,digits=0), signif(x,digits=6), cos(x), sin(x), tan(x), acos(x), asin(x), atan(x), acosh(x), asinh(x), atanh(x), abs(x) Al escribir > sqrt(2) aparecerá el valor de la raiz cuadrada de 2: [1] 1.414214 Al escribir > factorial(5) se obtendrá [1] 120

> log(((3+2)*5)+6) > x <- 2.567894 > x = 2.567894 >x > 4 * x^2 > peso <- c(54, 75, 51, 70, 49) > peso > sum(peso) > max(peso) > min(peso) > length(peso) > range(peso)

Equivale a log({(3+2)*5}+6) o log({{3+2}*5}+6) Asigna el valor 2.567894 a la variable x <- equivale en R a "=" aunque el "=" en R tiene otras peculiaridades en R por lo que usamos siempre <Asigna el valor 2.567894 a la variable x Muestra el valor actual de la variable x [1] 2. 567894 Muestra el resultado de multiplicar 4 por x elevado a 2 [1] 26.37632 Introducimos los pesos de 5 pacientes en la variable peso c significa concatenar Nos muestra los 5 valores introducidos [1] 54 75 51 70 49 Nos devuelve la suma de los 5 valores del vector peso [1] 299 Nos devuelve el máximo de los 5 valores del vector peso [1] 75 Nos devuelve el mínimo de los 5 valores del vector peso [1] 49 Nos devuelve el número de valores introducidos en el vector peso [1] 5 Nos devuelve el menor y el mayor valor entre los 5 valores del vector peso 31

>mean(peso) >median(peso)

[1] 49 75 Nos devuelve la media de los 5 valores del vector peso [1] 59.8 Nos devuelve la mediana de los 5 valores del vector peso [1] 54 Introducimos las tallas de 5 pacientes en la variable talla

> talla<-c(1.65, 1.71,1.63,1.62,1.58) > imc<-peso/talla^2 Efectúa la operación componente a componente de los vectores

[1] 19.83471 25.64892 19.19530 26.67276 19.62826 Asigna a la variable imc los reultados de la operación Nos muestra los valores almacenados en imc [1] 19.83471 25.64892 19.19530 26.67276 19.62826 Muestra los valores del vector imc mayores de 22.5 imc>22.5 [1] FALSE TRUE FALSE TRUE FALSE crea un vector llamado v con cuatro valores v <- c(2,1,3,4) nos muestra el valor de dicho vector v [1] 2 1 3 4 crea un vector llamado w w <- c(0,2,-2,1) nos muestra la tercera componente de w w[3] [1] -2 las operaciones afectan a todas las componentes 2*v-3*w+2 [1] multiplica componente a componente v*w [1] divide componente a componente w/v [1] eleva al cubo cada componente v^3 eleva cada componente de v a su correspondiente componente v^w de w produce un _warning_ por pedir que haga la raíz de un negativo sqrt(w) une los dos vectores y los almacena en uno nuevo vw vw<-c(v,w) muestra el resultado de vw vw une otra componente vwa<-c(vw,6) da un _warning_ pues ambos vectores no tienen el mismo vwa/v número de componentes. Pero, ¿¾qué hace? • Sin embargo, lo que convierte a R en una potente herramienta de trabajo es que está diseñado de forma que la mayoría de operaciones (p.e. +,-,*,/, etc.) y de funciones (p.e. log()) están definidas con carácter vectorial, es decir para operar componente a componente.

> imc<-peso/talla^2 > imc > > > > > > > > > > > > > > >

•

Es conveniente pues, en la medida de lo posible, explotar dicha posibilidad ya que agiliza en mucho el tiempo de computación.

•

La función principal para definir un vector es a través de sus componentes, con la función c(), mediante el comando más importante en R que es '<-' el de la asignación.

•

Los paréntesis () se emplean para los argumentos de las funciones y para agrupar expresiones algebráicas. Los corchetes [ ] o dobles corchetes [[ ]] para seleccionar partes de un objeto así como el $. Las llaves { } para agrupar expresiones.

•

Para referirnos a la componente enésima del vector v escribimos v[n].

NUESTRA PRIMERA SESIÓN CON R La siguiente sesion pretende presentar algunos aspectos del entorno R, utilizándolos. Muchos de estos aspectos le serán desconocidos e incluso enigmáticos al principio, pero esta sensación desaparecerá rápidamente. La sesión está escrita para el sistema UNIX, por lo que es posible que los usuarios de Microsoft Windows deban realizar pequeños cambios. Conéctese e inicie el sistema de ventanas. Es necesario que disponga del archivo `morley.data' en su directorio de trabajo, por lo que, si es necesario, deberá copiarlo. Si no sabe hacerlo, consulte con un experto local. Si ya lo ha copiado, continúe. >R Ejecute R. Comienza R y aparece el mensaje inicial. (Dentro de R no mostraremos el símbolo de `preparado' en la parte izquierda para evitar confusiones.) > help.start() Muestra la ayuda interactiva, que está escrita en formato html, utilizando el lector WEB disponible en el ordenador. Si utiliza esta ayuda comprenderá mejor el funcionamiento de R. Minimice la ventana de ayuda y continúe la sesión. > x <- rnorm(50) Genera dos vectores que contienen cada uno 50 > y <- rnorm(x) valores pseudoaleatorios obtenidos de una distribución normal (0,1) y los almacena en x e y. > plot(x, y) Aparecerá una ventana gráfica automáticamente. En ella se representan los puntos antes generados, tomando cada componente de x y de y como las coordenadas de un punto del plano. > ls() Presenta los nombres de los objetos existentes en ese momento en el espacio de trabajo de R. > rm(x, y) Elimina los objetos x e y > x <- 1:20 Almacena en x el vector (1; 2; . . . ; 20) > w <- 1 + sqrt(x)/2 A partir del vector x, crea un vector ponderado de desviaciones típicas, y lo almacena en w. > hoja.de.datos <- data.frame(x=x, y= x Crea una hoja de datos de dos columnas, llamadas x e + rnorm(x)*w) y, y la almacena en hoja.de.datos. A continuación la > hoja.de.datos presenta en pantalla. > regr <- lm(y _ x, data=hoja.de.datos) > summary(regr) > regr.pon <lm(y _ data=hoja.de.datos, weight=1/w^2) > summary(regr.pon) > attach(hoja.de.datos) > regr.loc <- lowess(x, y) > plot(x, y) > lines(x, regr.loc$y) > abline(0, 1, lty=3)

Realiza el ajuste de un modelo de regresión lineal de y sobre x, lo almacena en regr y presenta en pantalla un resumen del análisis. x, Puesto que se conocen las desviaciones típicas, puede realizarse una regresión ponderada. Conecta la hoja de datos, de tal modo que sus columnas aparecen como variables. Realiza una regresión local no paramétrica. Representa el gráfico bidimensional estándar. Le añade la regresión local. Le añade la verdadera recta de regresión (punto de corte 0, pendiente 1). 33

> abline(coef(regr)) > abline(coef(regr.pon), col = "red")

Le añade la recta de regresión no ponderada. Le añade la recta de regresión ponderada.

> detach()

Desconecta la hoja de datos, eliminándola de la trayectoria de búsqueda. Un gráfico diagnóstico de regresión para investigar la posible heteroscedasticidad.

> plot(fitted(regr), resid(regr), > xlab="Predichos", > ylab="Residuos", > main="Residuos / Predichos") > qqnorm(resid(regr), main="Residuos Gráfico en papel probabilístico normal para comprobar por rangos") asimetría, aplastamiento y datos anómalos. (No es muy útil en este caso) > Elimina los objetos creados. rm(x,w,hoja.de.datos,regr,regr.pon,regr.l oc) > file.show("morley.data") Presenta el contenido del archivo. > mm <- read.table("morley.data") Lee los datos de Michaelson y Morley y los almacena en > mm la hoja de datos mm, y la muestra en pantalla a continuación. Hay cinco experimentos (columna Expt) y cada uno contiene 20 series (columna Run) y la columna Speed contiene la velocidad de la luz medida en cada caso, codificada apropiadamente. > mm$Expt <- factor(mm$Expt) Transforma Expt y Run en factores. > mm$Run <- factor(mm$Run) > attach(mm) Conecta la hoja de datos en la posición predeterminada: la 2. > plot(Expt, Speed, main="Velocidad de Compara los cinco experimentos mediante diagramas la luz", xlab="No. Experimento") de cajas. > fm <- aov(Speed _ Run + Expt, Analiza los datos como un diseño en bloques data=mm) aleatorizados, tomando las `series' y los `experimentos' > summary(fm) como factores. > fm0 <- update(fm, . _ . - Run) Ajusta el submodelo eliminando las `series', y lo > anova(fm0,fm) compara utilizando un análisis de la varianza. > detach() Desconecta la hoja de datos y elimina los objetos > rm(fm, fm0) creados, antes de seguir adelante. Consideraremos ahora nuevas posibilidades gráficas. > x <- seq(-pi, pi, len=50) x es un vector con 50 valores equiespaciados en el > y <- x intervalo [-pi, pi] . El vector y es idéntico a x. > f <- outer(x, y, function(x, y) cos(y)/(1 + f es una matriz cuadrada, cuyas filas y columnas están x^2)) indexadas por x e y respectivamente, formada por los valores de la función cos(y)=(1 + x2). > oldpar <- par(no.readonly = TRUE) Almacena los parámetros gráficos y modifica el > par(pty="s") parámetro pty (zona de dibujo) para que valga \s" (cuadrado). > contour(x, y, f) Dibuja un mapa de curvas de nivel de f; y después le > contour(x, y, f, nlevels=15, add=TRUE) añade más líneas para obtener más detalle. > fa <- (f-t(f))/2 Dibuja un mapa de curvas de nivel > fa es la \parte asim_etrica" de f. (t(f) es la traspuesta de f). > contour(x, y, fa, nint=15) > par(oldpar) y recupera parámetros gráficos originales 34

> image(x, y, fa) > image(x, y, f) > objects(); rm(x, y, f, fa)

> th <- seq(-pi, pi, len=100) > z <- exp(1i*th) > par(pty="s") > plot(z, type="l") > w <- rnorm(100) + rnorm(100)*1i

Dibuja dos gráficos de densidad Presenta los objetos existentes y elimina los objetos creados, antes de seguir adelante. Con R también puede utilizar números complejos. 1i se utiliza para representar la unidad imaginaria, i. La representación gráfica de un argumento complejo consiste en dibujar la parte imaginaria frente a la real. En este caso se obtiene un círculo. Suponga que desea generar puntos pseudoaleatorios dentro del círculo unidad. Un primer intento consiste en generar puntos complejos cuyas partes real e imaginaria, respectivamente, procedan de una normal (0,1) ...

> w <- ifelse(Mod(w) > 1, 1/w, w)

...y sustituir los que caen fuera del círculo por sus inversos. > plot(w, xlim=c(-1,1), ylim=c(-1,1), Todos los puntos están dentro del círculo unidad, pero pch="+",xlab="x", ylab="y") la distribución no es uniforme. lines(z) > w <- Este segundo método utiliza la distribución uniforme. En sqrt(runif(100))*exp(2*pi*runif(100)*1i) este caso, los puntos presentan una apariencia más > plot(w, xlim=c(-1,1), ylim=c(-1,1), > uniformemente espaciada sobre el círculo. pch="+", xlab="x", ylab="y") > lines(z) > rm(th, w, z) > q()

De nuevo elimina los objetos creados, antes de seguir adelante. Termina el programa R. Se le preguntará si desea salvar el espacio de trabajo. Puesto que esta sesión ha sido solamente de presentación, probablemente deberá contestar que no.

INTRODUCIR DATOS en R Lectura de datos Existen variadas formas de introducir los datos en R, la más básica, es mediante scan() scan(file=" ", what = numeric(), n, sep, ...)

> scan( )

> mis.datos <- scan() > mis.datos<-scan("c:\\datos\\datos.txt") > mis.datos<-scan(,what=character(),3) 1: soltero 2: casado 3: viudo Read 3 items > mis.datos [1] "soltero" "casado" "viudo" cat('Número de pruebas?', '\n') m<-scan("",n=1, quiet=TRUE)

Se abre ventana y vamos introduciendo lo deseado 1: 4 2: 100 3: 3.14159 4: Tras dejar uno en blanco con ENTER el proceso termina: Read 3 items [1] 4 100 3.14159 Almacenamos los datos iontroducidos en la variable mis.datos Almacena en la variable mis.datos lo contenido en un supuesto fichero de mi disco llamado datos.txt Crea un vector mis.datos de 3 componentes tipo character

Visualiza un mensaje "Número de pruebas?" en consola que ayuda a introducir el valor posterior Pide en consola el valor de la variable m

Otra forma, igual de básica, es directamente por asignación con código,

dato1 <- 50 dato2 <- "solero" dato3 <- 1:5 dato3 datos <- c(dato1,dato2,dato3)

datos

# Asigna 50 a la variable data1 # Asigna "soltero" a la variable data2 # Asigna un vector (1,2,3,4,5) a la variable data3 [1] 1 2 3 4 5 # Concatena todos los valores, en un único vector, en la variable datos que sera tipo character porque se unifican los tipos automáticamente [1] "50" "solero" "1" "2" "3" "4" "5"

> x<-seq(10) > x<-seq_len(10) > x<-seq(-10,10) > x<-seq(-10,10, by=2)

Los mismo que 1:10 Los mismo que 1:10 Carga un vector desde -10 hasta 10 Carga un vector desde -10 hasta 10 saltando de 2 en 2 36

> x<-seq(0,5, by=0.5) > seq(stats::rnorm(20)) > rep (1:4,2)

Carga un vector desde 0 hasta 5 saltando de 0.5 No lo se Repite dos veces la secuencia 1 a 4 [1] 1 2 3 4 1 2 3 4 [1] 1 1 2 2 3 3 4 4 [1] 1 1 2 2 solo coge los 4 primeros [1] 1 1 2 2 3 3 4 4 4 [1] 1 1 2 2 3 3 4 4 1 1 2 2 3 3 4 4 1 1 2 2 3 3 4 4 [1] 5 7 2 5 7 2 5 7 2 [1] 5 5 5 7 7 7 2 2 2

> rep(1:4, each = 2) > rep(1:4, each = 2, len = 4) > rep(1:4, c(2,2,2,3)) > rep(1:4, each = 2, times = 3) > rep(c(5, 7, 2), 3) > rep(c(5, 7, 2), each=3)

Una tercera forma es ley茅ndolos del disco mediante read.table(file, header = F, sep = "", ...) Si deseamos especificar pondremos header=T.

que

primera

fila

contiene

los

nombres

las

variables

Una cuarta forma es leyendo de una direcci贸n de Internet read.table("http://ichart.yahoo.com/table.csv?s=AMS.MC&a=0&b=1&c=2010&d=2&e=19&f=20 15&g=d&ignore=.csv", header=TRUE, sep=",") Veamos algunos ejemplos sobre la tabla datos creada anteriormente:

> write.table(datos, "c:\\cursoada\\datos1.txt")

C:\cursoADA>more datos1.txt "edad" "altura" "paco" 20 174 "pepe" 22 180 "kiko" 19 170

> write.table(datos, "c:\\cursoada\\datos1.txt",quote=F)

C:\cursoADA>more datos1.txt edad altura paco 20 174 pepe 22 180 kiko 19 170

> write.table(datos,"c:\\cursoada\\datos1.tx t",quote=F,row.names=F)

C:\cursoADA>more datos1.txt edad altura 20 174 22 180 19 170

Escritura de datos Escribir en R los datos que hemos calculado es tan sencillo como escribir simplemente el nombre de la variable 37

> x<-1:5 >x

Crea un vector x con los valores de 1 a 5 Los escribe en consola

> print(x)

Igual que x pero dispone de muchas opciones adicionales . Escribe ?print en cosola para ayuda.

Si lo que queremos es escribir los datos obtenidos en un fichero en disco, la orden análoga a read.table para escribir una tabla en disco es: write.table(x, file = "", append = FALSE, quote = TRUE, sep = " ", row.names = TRUE, col.names = TRUE) Aparte de utilizar la función write.table() , podemos utilizar la función write(). Supongamos que queremos guardar en un fichero el contenido de un vector:

> x<-1:5

# Asigna a x un vector numerico de 5 componentes

> write(x,"c:\\cursoada\\x.txt")

# Graba en disco un fichero x.txt que contendrá los 5 valores del vector x

> x<-matrix(1:9,ncol=3,byrow=T) >x [,1] [,2] [,3] [1,] 1 2 3 [2,] 4 5 6 [3,] 7 8 9

# Creamos una matriz 3x3 llamada x # La visualizamos

> write(t(x),"c:\\cursoada\\x.txt",ncol=n col(x))

# La escribimos en el fichero x.txt pero ¡cuidado! # La función write() actúa escribiendo una columna de la matriz cada vez, por lo que primero deberemos trasponer. El número de columnas en este caso es 3, pero indicando ncol(x) nos aseguramos de acertar siempre.

IMPORTAR y EXPORTAR DATOS en R Nadie va a cuestionar a estas alturas la eficacia, la potencia y la comodidad de Microsoft Excel para manejar datos en tablas. Más aún, la potencia para manejar datos en general. Excel ofrece soluciones a prácticamente todos los campos del cálculo, la empresa y la estadística. Incuye infinidad de librerías propias y externas y encierra un lenguaje de programación, el VBA (Visual Basic for Applications), que permite desarrollar aplicaciones para cualquier propósito. El fin de que estemos aprendiendo R no es otro que el poder manejar datos de cotizaciones financieras con el fin de estudiar métodos cuantitativos y poder aportar y aprovechar el caudal de conocimientos y librerías que miles de usuarios de este programa están facilitando en el repositorio. Es muy probable que todo lo que pretendemos investigar se pueda hacer con Excel y que no necesitaríamos R, pero es también seguro que si los desarrollos avanzan a la velocidad esperada, pronto llegaremos a un punto donde el manejo de datos en Excel se haga ineficaz. De ahí poder contar con un programa como R, disponible para todas las plataformas y mucho más orientado a los campos por los que pretendemos caminar, que te recuerdo que son •

Probabilidad

•

Procesos estocásticos

•

Métricas cuantitativas

•

Data Mining

•

Redes Neuronales

•

Análisis de patrones

•

Métodos de Money Management

•

Análisis de Riesgo

¿Por qué digo ahora ésto? pues porque toca aprender a importar y exportar datos, principalmente a Excel, ya que Excel nos facilita mucho la labor en tareas básicas, aparte de su poder visual. Y quien dice Excel dice Drive y cualquier otro programa como puede ser directamente texto. Si el hecho de aprender a programar R es importante, este capítulo de resulta vital dentro de este castillo de conocimiento que estamos desarrollando.

¿ De dónde obtenemos los datos? En nuestros estudios vamos a manejar históricos de datos de cotizaciones de activos financieros. El programa más universal para realizar chartismo de estos datos es el Metastock (R)

aunque en España tenemos la fortuna de haber desarrollado y poder disfrutar del excelente VisualChart

que camina hacia los 20 años en el mercado, es de gran calidad y dispone de todas las herramientas necesarias para el análisis técnico y será en el que nos apoyemos para hacer estudos gráficos. Hay muchos importantes programas más, todos ellos reciben y grafican datos financieros para poder hacer análisis técnicos sobre ellos, pero la suscripción a recibir dichos datos en tiempo real es de pago. Si solo deseamos los datos "fin de día" ó EOD (end of day) VisualChart nos los ofrece gratuítamente. En cualquier caso esos datos están codificados por ellos y para ellos y nosotros vamos a tener que cocinarlos en base a nuestras investigaciones, por lo que tenemos que tener un dominio absoluto de como son y como poder adaptarlos. También tenemos la posibilidad de usar Google o Yahoo Finance (https://es.finance.yahoo.com/) que nos permite obtener gratuitamente bases de datos históricas de todos los mercados mundiales e, incluso, poder pasarlos a Excel y actualizar nuestras propias bases de datos.

La importancia de tener bases de datos históricas, bien cuidadas y actualizadas, es vital porque de esos datos sacaremos conclusiones de estrategias futuras. Si esos datos no son correctos las conclusiones no serán fiables y nuestro proyecto se derrumbará antes de empezar. Aunque tranquilo porque cualquier estrategia que diseñemos tendrá su periodo de prueba igual que a un medicamento se le exige un largo periodo de ensayos que determinen su calidad, eficacia y seguridad antes de su comercialización. Incluso se podría dar el caso que adoptemos estartegias mal diseñadas y aún así resulten efectivas, que es lo que necesitamos. En resulmen, hoy por hoy, Marzo de 2015, para poder avanzar en nuestro proyecto de la forma más limpia y cómoda es que elaboremos programas que nos permitan disponer de nuestras propias bases de datos de históricos de cotizaciones siguiendo estas características: •

Poder leer las numerosas bases de datos históricas Metastock disponibles

•

Poder leer bases de datos históricas de Visualchart y Yahoo Finance.

•

Poder usar Excel con todas estas bases de datos.

•

Almacenar, para nuestra gestión, todos los datos a formato texto CSV (CommaSeparated Values) que es apropiado para Excel y R (e incluso por cualquier editor de texto), usando inicialmente los campos Date Time Ticker Open High Low Close Volume, pero teniendo en mente que hay otros campos interesantes que, de ser posible, habría que añadirlos como son el Open Interest , operaciones extraordinarias, splits, dividendos, ampliaciones, excepciones, anomalías, y un largo etcetera.

•

Alimentar nuestras bases de datos, en un principio, a través de Yahoo Finanzas en periodos EOD y en el intradiario de, al menos, 15 minutos , pero con la idea de disponer en un futuro cercano, de un sistema propio de alimentación datos en tiempo real (RT real time)

Hay que pensar que vamos a investigar cualquier tipo de activo financiero, incluidos los Fondos cotizados (ETFs Exchange-Traded Fund) las commodities o o los Hedge Funds y sus bases de datos no son las mismas que las de una acción, no tienen los mismos campos, aunque tampoco tienen que ser muy distintas. Vamos pues a estudiar ahora como poder llevar a cabo todo esto, aunque usaremos ejemplos no necesariamente financieros.

Importar ficheros CSV Los ficheros CSV (Comma-Separated Values) son cómodos de manipular, los puede leer Excel, R y cualquier editor de texto, incluido el bloc de notas de Windows. Estan formados por texto plano, separados por comas o puntos y comas y cada registro está separado del siguiente por un salto de línea. También es habitual que incluyan los nombres de las filas, en el primer campo de cada fila y las columnas, en el primer registro, tal y como vemos en el siguiente Ejemplo de fichero CSV

X,Y,Numero,TipoCopa,AnchoCopa,Altura Copa,Altura Tronco,Opacidad,Ene,Feb,Mar,Abr,May,Jun,Jul,Ago,Sep,Oct,Nov,Dic,Clase,Crecimiento Ancho Copa, Crecimiento Altura Copa, Crecimiento Altura Tronco 0,0,1,Elipsoidal,3,3,3,90,100,100,100,100,100,100,100,100,100,100,100,100,, 4,5,6 34,34,2,Conica,6,6,6,80,100,100,100,100,100,100,100,100,100,100,100,100,Cipres 20,20,3,Semielipsoidal,4,4,4,70,100,100,100,100,100,100,100,100,100,100,100,100,Pino 3,3,0,Marca,0,0,0,100,100,100,100,100,100,100,100,100,100,100,100,100,Cipres 4,4,0,Marca,0,0,0,100,100,100,100,100,100,100,100,100,100,100,100,100,Cipres 67,50,0,Marca,0,0,0,100,100,100,100,100,100,100,100,100,100,100,100,100,Clase22 99,99,4,Conica,8,8,8,60,60,100,60,100,60,100,60,100,60,100,60,100,Cipres Es absolutamente necesario que el fichero CSV sea consistente y sin ningun tipo de error. Ten en cuenta que al pasar de Excel a CSV pueden haber celdas combinadas, celdas vacías o tipos de datos que pueden confundir al programa al crear el CSV y después no ser legible por R. También hay que evitar los caracteres extraños en las etiquetas de los nombres de las filas o columnas como el €,ñ, %, !, ?, $, etc. Si hay datos perdidos, sin valor, su codificación también tiene que ser consistente. R emplea NA para valores ausente así que lo óptimos ería usar en nuestros CSV la misma codificación.

> read.csv(file="filename")

Comando que lee un archivo CSV, se asume que en la primera fila están los nombres de las columnas en el primer campo de cada fila están los nombres de las filas > datos = read,csv( "NOMBRE.csv", Se le puede asignar un nombre a ese conjunto d edatos sep=";", dec=",") y especificar si el separador es "," o ";" Ejemplo 2 EjemploCSVSinFilasConColumnas.csv altura,peso,edad 175,87,32 187,82,36 176,56,23 165,68,39 42

Este csv tiene en el primer registro los nombres de las tres columnas. El comando para su importación es > datos <- read.csv(file="..../datos/ EjemploCSVSinFilasConColumnas.csv") Ejemplo 3 EjemploCSVConFilasConColumnas.csv altura,peso,edad "Juan",175,87,32 "Pedro",187,82,36 "José",176,56,23 "María",165,68,39 Este csv tiene en el primer registro los nombres de las tres columnas y de las cuatro filas. El comando para su importación es > datos <- read.csv(file="..../datos/EjemploCSVConFilasConColumnas.csv")

Ejemplo 4 EjemploCSVSinFilasSinColumnas.csv 175,87,32 187,82,36 176,56,23 165,68,39 Este csv no tiene etiquetas ni para filas ni para columnas. El comando para su importación es > datos <- read.csv(file="..../datos/EjemploCSVSinFilasSinColumnas.csv")

Exportar ficheros CSV Si lo que queremos es exportar objetos disponibles en la memoria de R a un archivo formato CSV el comando es > write.csv(file="filename")

Comando que escribe objeto R en un archivo CSV,

Libreria XLConnect El comando scan() Ya hemos hablado de él para introducir datos desde teclado pero no hemos hablado de lo útil que puede resultar para importar y exportar desde Excel hacia o para R. Por lo de pronto, que sepas scan( ) puede importar datos del clipboard previamente copiados con CTR+C Ejemplo Imaginemos una tabla Excel como la que sigue y que queremos importar los datos de la columna F (glu)

> temp <-scan() CTR+V Pulsamos enter para finalizar scan > temp

Pegamos los datos previamente copiados con CTR+C Nos muestra el vector de datos introducidos [1] 11.8 11.4 12.5 10.5 9.8 9.6 6.6 6.9 8.4 9.6 7.7 6.9 4.5

Antes de nada, necesitaremois un paquete especial llamado XLConnect para poder realizar estas tareas enmtre R y Excel (tanto extensión xls de Excel 2003 como extensión xlsx de Excel 2007 en adelante) La última versión de la librería XLConnect, a fecha de hoy Marzo 2015, es precisamente de Marzo 2015 (http://cran.r-project.org/web/packages/XLConnect/XLConnect.pdf). Es una librería muy amplia y potente, con muchísimas fórmulas y gracias a ella Excel y R quedan perfectamente sincronizados para poder usarlos conjuntamente. Primero carga el paquete del repositorio R > Paquetes > Instalar paquetes> .... 44

deberás elegir un servidor R en cualquier pais que desees y después eliges el paquete XLConnect Haciéndolo mediante comandos: utils:::menuInstallPkgs()

probando la URL 'http://cran.es.rproject.org/bin/windows/contrib/3.1/XLConnect_0.2-11.zip' Content type 'application/zip' length 5122767 bytes (4.9 Mb) URL abierta downloaded 4.9 Mb package ‘XLConnect’ successfully unpacked and MD5 sums checked The downloaded binary packages are in

> library(XLConnect)

C:\Users\.........\AppData\Local\Temp\Rtmp2FEsZO\downloaded_ packages Loading required package: XLConnectJars Error : .onLoad failed in loadNamespace() for 'rJava', details: call: fun(libname, pkgname) error: No CurrentVersion entry in Software/JavaSoft registry! Try re-installing Java and make sure R and Java have matching architectures. Además: Mensajes de aviso perdidos 1: package ‘XLConnect’ was built under R version 3.1.3 2: package ‘XLConnectJars’ was built under R version 3.1.3 Error: package ‘XLConnectJars’ could not be loaded

Vamos, por un lado, a crear una hoja Excel en blanco que llamaremos "prueba.xlsx", y después la vinculamos con R wb <loadWorkbook("prueba.xlsx ", create = TRUE) createSheet(wb, name="hoja1") saveWorkbook(wb) > id<-1:20 > lista_A<-runif(20) > lista_B<-rep(100,20) > base<-data.frame(id, lista_A,lista_B) > base

Nos carga ( pero aquí lo crea al usar create = T) dentro de R un workbook que denominaré en R wb en blanco que se llamara prueba.xlsx Crea dentro de wb una hoja que se llama hoja1 Salva en disco este libro de Excel wb Creamos tres vectores uno id desde 1 hasta 20 Otro, lista_A con 20 numeros aleatorios entre 0 y 1 Otro más, lista_B, que repita 20 veces el numero 100 Creo un data.frama con estos tgres vectores y lo visualizo id lista_A lista_B 1 1 0.223818584 100 2 2 0.836814989 100 3 3 0.369092558 100 4 4 0.583468457 100 5 5 0.584182021 100 6 6 0.923651852 100 7 7 0.253115505 100 8 8 0.520282311 100 9 9 0.082687126 100 10 10 0.004077846 100 11 11 0.666228890 100 45

Wb <loadWorkbook("basedesdeR .xlsx", create = TRUE) createSheet(wb, name="lista") createName(wb, name="lista", formula="lista!$A$1") writeNamedRegion(wb, base, name="lista") saveWorkbook(wb)

12 12 0.198847276 100 13 13 0.540410568 100 14 14 0.415327411 100 15 15 0.436540104 100 16 16 0.143449819 100 17 17 0.557196635 100 18 18 0.062900618 100 19 19 0.812096852 100 20 20 0.949530015 100 Carha el fichero "basedesdeR.xlsx" pero al usar la opcion create = TRUE en lugar de cargarlo, en realidad lo crea. Creo la hoja de nombre "lista" Situa un puntero en la casilla A1 de Excel Escribe en la joha abierta el data.frame base antes definido

Si tratamos de abrirlo desde Excel verรกs que aparece

Ahora al revés, habíamos creado una hoja de cálculo en Excel llamada "workbook.xlsx" y creamos en ella dos hojas, una llamada "glu" y otra "Prueba2"

Para traerla a R hacemos wb <- loadWorkbook("workbook.xlsx", create = FALSE) dataExcel <- readWorksheet(wb, sheet = "Prueba2") dataExcel <- readWorksheet(wb, sheet = "glu") > file.import="filename.xlsx"

Carga en R una hoja de Excel llamada workbook.xlsx Lee datos de la hoja y los almacena en un data.frame llamado dataExcel error Esto si me fuinciono r-help-es@r-project.org Importa una hoja Excel

> file.load=loadWorkbook( file.import, create=FALSE)

La carga en memoria en un fichero que se llama file.load

> MyData <- readWorksheet (file. load, sheet=1) > createSheet (wb, name = "datos") > createName(wb,name="datos", formula = "datos!$a$1") > writeNameRegion (wb, MyData, name = "datos") > saveWorkbook(wb)

Asigno a MyData la data.frame traida de Excel

Lo salva. Si ahora vamos a Excel veremos estos datos allí. 47

df <- readWorksheet(wb, sheet = "Conversion", header = TRUE, colTypes = c(XLC$DATA_TYPE.NUMERIC, XLC$DATA_TYPE.DATETIME, XLC$DATA_TYPE.BOOLEAN), forceConversion = TRUE, dateTimeFormat = "%Y-%m-%d %H:%M:%S")

Importando y exportando datos > save( , ,file="filename.RData") > save.image (file="filename.RData") > load("filename.RData") > dump("...","...","filename.r",append=T) > source("filename.r") > write.table(data.frame,"filename.txt",s ep="\t", quote=F) > read.table("filename.txt",header=T,,se p="\t")

Guarda ficheros formato .RData Guarda todo el directoriod e trabajo Recupera fichero .RData Guarda ficheros formato .r Recupera fichero filename.r Guarda ficheros formato ASCII filename.txt Recupera ficheros formato ASCII filename.txt

Segunda Manera Vamos a ver una forma más antigua y muy operativa, aunque menos versátil que la anterior. Para ello utilizaremos los comandos • • •

read.csv read.table library(RODBC) o -odncConnectExcel2007 o -odncConnectExcel

Vamos a Excel y tenemos una hoja con datos. La salvamos en formato csv.

Ahora vamos a R y la leemos

> data1 <- read.csv( "f:/40 financial/r/ibw.csv", header=T, sep=";" )

Lee la base de datos y la visualiza, especificando que hay cabecera y que el separador es ";"

> data1

1 2 3 4 5 6

id low age lwt race smoke ht ui bwt 85 0 19 182 2 0 0 1 2523 86 0 33 155 3 0 0 0 2551 87 0 20 105 1 1 0 0 2557 88 0 21 108 1 1 0 1 2594 89 0 18 107 1 1 0 1 2600 90 0 21 124 3 1 0 0 2622

.......................................................... ..........................................................

Si tenemos que editar una tabla o data.frame no es necesario volver a Excel, podemos hacerlo en erl mismo R yendo a Editor ->itor de datos (data1) y aparece

Cuando salgamos, la tabla estar谩 activa y modificada en R (no en Excel) Otra opci贸n es salvar la tabla de Excel en modo .txt La podemos visualizar en el bloc de notas

y ahora vamos a leerla en R con el comando > data2 <- read.table( "f:/40 financial/r/ibw.txt", header=T) > data2

Lee la base de datos ibw.txt especificando que hay cabecera 1 2 3 4 5

visualiza,

id low age lwt race smoke ht ui bwt 85 0 19 182 2 0 0 1 2523 86 0 33 155 3 0 0 0 2551 87 0 20 105 1 1 0 0 2557 88 0 21 108 1 1 0 1 2594 89 0 18 107 1 1 0 1 2600

.......................................................... ..........................................................

Tambien se puede leer con copia y pega. Seleccionamos en Excel y copiamos con el menu o con CTRL-C y pegamos en R mediante el comando > data3 <- read.table( "clipboard", header=T) > data3

Lee lo que hay almacenado en el clipboard

1 2 3 4 5

id low age lwt race smoke ht ui bwt 85 0 19 182 2 0 0 1 2523 86 0 33 155 3 0 0 0 2551 87 0 20 105 1 1 0 0 2557 88 0 21 108 1 1 0 1 2594 89 0 18 107 1 1 0 1 2600

.......................................................... ..........................................................

Y ¿qué ocurriría si nuestro libro Excel tuviese más de una hoja? Para esto tenemos que usar la libreria RODBC

> install.packages("RODBC") > library(RODBC) > canalexcel <odbcConnectExcel2007("lbw.xlsx")

RODBC significa conexion entre R y Open Data Base connectivity La cargamos en memoria Establecemos un canal que conectara R con Excel

Ejemplo Fuente https://dl.dropboxusercontent.com/u/7610774/CursoR/xlconnect.R # ================================= # Guardar datos en un archivo excel # ================================= x=rnorm(100) y=rnorm(100) z=runif(100) misDatos=data.frame(x,y,z) # Cargamos el paquete XLConnect require(XLConnect) # Para guardar el data.frame "misDatos" ejecutamos el siguiente comando (es obligatorio especificar nombre de hoja): writeWorksheetToFile("prueba.xlsx",data=misDatos,sheet="hojaDatos")

# En caso de que se deseen guardar distintos data.frames en varias hojas del mismo libro excel resulta más conveniente # el siguiente procedimiento: xlsfile = loadWorkbook("prueba2.xlsx", create = TRUE) # Creamos el libro de trabajo donde vamos a guardar los datos xlsfile["hojaDatos1"] = misDatos # Guardamos los datos en la hoja "hojaDatos1" xlsfile["hojaDatos2"] = data.frame(x,y) # Guardamos solo las variables x e y en la hoja "hojaDatos2" xlsfile["hojaDatos3"] = data.frame(z) # Guardamos solo la variable z en la hoja "hojaDatos3" saveWorkbook(xlsfile) # Escribe el archivo físicamente en el disco.

# ============================== # Leer datos de un archivo Excel: # ============================== # Cargamos el paquete XLConnect require(XLConnect) # Leemos la primera hoja de cálculo del libro "prueba.xlsx" mediante: datos <- readWorksheetFromFile("prueba.xlsx",sheet=1) # Lee la hoja 1, cualquiera que sea su nombre 52

# Si queremos leer una hoja concreta, especificamos su nombre: datos <- readWorksheetFromFile("prueba.xlsx",sheet="hojaDatos") "hojaDatos"

# Lee la hoja

# Si vamos a leer varias hojas de un mismo libro resulta mรกs conveniente: xlsfile = loadWorkbook("prueba2.xlsx") datos1 = xlsfile["hojaDatos1"] datos2 = xlsfile["hojaDatos2"] datos3 = xlsfile["hojaDatos3"]

OPERACIONES ARITMÉTICO-LÓGICAS.

Operaciones aritméticas Las operaciones aritméticas en R se escriben con los siguientes operadores: •

Suma: +

•

Diferencia: -

•

Producto *

•

División /

•

Exponenciación ^

•

Raiz cuadrada sqrt(x)

Pero hay muchas más operaciones •

Valor absoluto abs(x)

•

factorial factorial(x)

•

Binomio de n sobre x choose(n,x)

•

División entera %/%

•

Modulo resto división entera %%

•

logaritmos log log10 log2 logb(x,base) log1p(x)

•

exponenciales exp(x) expm1(x)

•

trigonometricas sen, cos, tan, asin, acos, atan, atan2(y,x)

•

redondeo ceiling, floor, round, signif, trunc

•

Estadisticas max, min, range, pmax, pmin, mean, median, var, sd, quantile

•

Otras

sum, prod, diff cumsum, cumprod, cummax, cummin

Por ejemplo: > x <- 4 > y <- 3 > suma<- x+y > suma [1] 7 > difer <- x–y > difer [1] 1 > producto <- x*y

Asignamos a x el valor 4 Asignamos a y el valor 3 Asignamos a suma el valor de x + y Si lo preguntamos obtenemos 7 Asignamos a difer el valor de x + y Si lo preguntamos obtenemos 1 Asignamos a producto el valor de x * y 54

> producto [1] 12 > division <- x/y > division [1] 1.33333 > potencia <- x^y > potencia [1] 64

Si lo preguntamos obtenemos 12 Asignamos a division el valor de x / y Si lo preguntamos obtenemos 1.3333 Asignamos a potencia el valor de x^y Si lo preguntamos obtenemos 64

Operaciones de comparación Las operaciones de comparación en R se escriben con los siguientes operadores: •

Mayor que: >

•

Mayor o igual que: >=

•

Menor que: <

•

Menor o igual que: <=

•

Igual a: ==

•

Distinto de: !=

•

Funcion xor( )

Estas operaciones devuelven un valor lógico TRUE o FALSE. Por ejemplo: > x<-5 > y <-3 >x<y [1] FALSE > y<x [1] TRUE > x >= 10 [1] FALSE > x == 5 [1] TRUE > x != y

Asignamos a x el valor 5 Asignamois a y el valor 3 Devuelve FALSE porque 5 no es menor que 3 Devuelve TRUE porque 3 es menor que 5 Devuelve FALSE porque 5 no es mayor o igual que 10 Devuelve TRUE porque x es igual que 5 Devuelve TRUE porque x es distinto que 5

Operaciones lógicas Las operaciones lógicas en R se escriben con los siguientes operadores: •

Conjunción (y): &&

•

Disyunción (o): || o | 55

•

Negación (no): !

Por ejemplo: (x > 5) && (y > 2) (x > 5) || (y > 2) !(x > 5) Podemos combinar en una expresión varias operaciones aritméticas y lógicas. Pero cuidado, las operaciones se aplicarán de forma automática según el orden de precedencia. Por ejemplo, el producto y la división tienen mayor precedencia que la suma y la diferencia. Para cambiar la precedencia por defecto es necesario utilizar paréntesis: combinacion.1 <- 3 * 5 + 10 / 2 combinacion.2 <- 3 * (5 + 10) / 2

Operaciones Con conjuntos Las operaciones conjuntistas en R se escriben con los siguientes operadores:

> > > > >

•

union: union(x,y)

•

Interseccion: intersec(x,y)

•

Conjunto diferencia: setdiff(x,y)

x <- 1:5 y <- c(1,3,7:10) union (x,y) intersecc(x,y) setdiff(y,x)

[1] 1 2 3 4 5 [1] 1 3 [1] 7 8 9 10

7 8 9 10

Operaciones con vectores. Algunas funciones útiles con vectores son: •

Longitud o número de elementos: length()

•

Mínimo y máximo: min(), max() pmax() pmin()

•

Índices del valor máximo y mínimo: which.max(), which.min()

•

Suma de los elementos o conteo de TRUEs: sum() pro() cumsum() cumprod() cummin() 56

•

Media y mediana: mean(), median() sd() var() IQR() range() summary() quantile()

•

Y otras como sort rev(sort) sort(x,dec=T) rank order

Por ejemplo: v <- c(5,10,0,0,2) length(v) min(v) max(v) which.min(v) which.max(v) sum(v) mean(v) median(v)

Operaciones con matrices •

Traspuesta : t()

•

Suma elemento a elemento: +

•

Producto elemento a elemento *

•

Producto matricial %*%

•

Producto cruzado crossprod (x,y) t(x) %*% y

•

Producto exterior: outer()

•

Determinante: det()

•

Inversa solve()

•

Valores propios eigen()

•

Descomposicion en valores singulares svd()

•

Descomposicion QR: qr()

•

Descomposicion de cholesky: chol()

•

Y otros: scale diag

Y también funciones especiales para matrices como •

Dimensiones: dim 57

•

Nombres de las dimensiones: dimnames

•

nombres de las columnas: colnames

•

nombres de las filas: rownames

•

Tipos de datos de los elementos: mode

•

Numero total de elementos: length

•

T o F para saber si una variable es tipo amtriz: is.matrix

•

acceder a elementos concretos: [,]

•

Funcione special apply()

•

Pega matrices por columnas: cbind

•

Pega matrices por filas: rbind

Valores espacieles reservados por el sistema •

TRUE T

es verdadero

•

FALSE F

es falso

•

NA, is.na

Datos perdidos (not available)

•

NaN is.anan

Indeterminado (Not a number)

•

NULL is.null

Objeto nulo o de longitud 0

•

Inf is.infinite Infinito (∞)

•

Numero pi (π )

•

Unidad imaginaria de los números complejos

•

letters LETTERS

letras minúsculas y mayúsculas

EXPRESIONES REGULARES Sáltate esto si consideras que no es todavía el momento de empezar a programar en plan serio. El poder de las expresiones regulares viene de su capacidad para detectar patrones en las cadenas de caracteres. Tienen una codificación especial denominada meta-caracteres que tendrás que aprender pero son realmente útiles a la hora de programar. Hay dos grupos de expresiones regulares o meta-caracteres, las compatibles con el estándar POSIX y las compatibles con el lenguaje de programación PERL Las expresiones regulares compatibles POSIX son

Metacaracteres Patrón Significado . Match con cualquier carácter ^c Match empezar por el carácter c (Dentro de corchetes este símbolo es de exclusión)

c$ \s \d \D \w \W \A \z \n \t \ (cd) c|d

Match terminar por el carácter c Match con un espacio en blanco Match con cualquier digito 0 1 2 ...9 Match con cualquier no digito Match con cualquier caracter que pueda ser parte de una palabra (letra, número, guión bajo) Match con cualquier caracter que NO pueda ser parte de una palabra (letra, número, guión bajo) Comienzo de un string Final de un string nueva línea tabulador escape, para escribir delante de caracteres especiales: ^ . [ ] % ( ) | * ? { } \ caracteres c y d agrupados carácter c o d

Cuantificadores c+ c* c? \n (cd) c{n} c{n,} c{n,m}

1 o más veces el caracter c 0 o más veces el caracter c 0 o 1 veces el caracter c nueva línea caracteres c y d agrupados n veces el carácter c n o más caracteres c desde n hasta m caracteres c

Agrupadores (cd) [ ] [a-z] [A-Z] [0-9] [cde] [c-f] [^c] ab[1-5]+c

( ) (a|b) [[:alnum:]] [[:alpha:]] [[:digit:]] [[:lower:]] [[:punct:]] [[:space:]] [[:upper:]]

caracteres c y d agrupados Permiten agrupar rangos cualquier letra minúscula cualquier letra mayúscula cualquier dígito entre 0 y 9 cualquiera de los caracteres c, d o e cualquier letra entre c y f (es decir, c, d, e o f) que no esté el carácter c OJO!, Sin embargo ^[aeiou] significa que empiece por una vocal. Ejemplo significa un string que contenga ab,una o mas veces [1-5]+ un número del 1 al 5 y le siga una c. Por ejemplo ab12c El contenido entre paréntesis permite crear sub-expresiones regulares contenidas en otras Que contenga la a o la b cualquier letra o dígito (pero no vocales acentuadas, ñ, ç, etc.) cualquier letra (pero no vocales acentuadas, ñ, ç, etc.) cualquier dígito cualquier letra minúscula (pero no vocales acentuadas, ñ, ç, etc.) cualquier marca de puntuación cualquier espacio en blanco cualquier letra mayúscula (pero no vocales acentuadas, ñ, ç, etc.)

Modificadores Los modificadores nos permiten cambiar la manera en que se ejecuta una expresión regular

i m S u x X A D S U J

Que coincidan indistintamente entre mayúsculas y minúsculas. Match multilínea Match con el caracter cambiod e línea Matchs en modo UTF8 Ignora los espacios cualquier letra o dígito (pero no vocales acentuadas, ñ, ç, etc.) cualquier letra (pero no vocales acentuadas, ñ, ç, etc.) cualquier dígito cualquier letra minúscula (pero no vocales acentuadas, ñ, ç, etc.) cualquier marca de puntuación

Además, las expresiones regulares compatibles con PERL admiten los siguientes patrones:

Patrón

Significado

[[:alnum:]] cualquier letra o dígito (incluidas vocales acentuadas, ñ, ç, etc.) [[:alpha:]] cualquier letra (incluidas vocales acentuadas, ñ, ç, etc.) 60

[[:ascii:]]

caracteres con código ASCII de 0 a 127

[[:blank:]] espacios o tabuladores [[:cntrl:]]

caracteres de control

[[:graph:]] caracteres de impresión, salvo el espacio [[:lower:]] cualquier letra minúscula (incluidas vocales acentuadas, ñ, ç, etc.) [[:print:]] caracteres de impresión, espacio incluido [[:upper:]] cualquier letra mayúscula (incluidas vocales acentuadas, ñ, ç, etc.) [[:word:]] cualquier letra o dígito y el guión bajo (incluidas vocales acentuadas, ñ, ç, etc.) [[:xdigit:]] cualquier dígito hexadecimal \w

cualquier letra o dígito y el guión bajo (incluidas vocales acentuadas, ñ, ç, etc.)

cualquier cosa que no sea letra o dígito y el guión bajo (incluidas vocales acentuadas, ñ, ç, etc.)

cualquier espacio en blanco

cualquier cosa que no sea un espacio en blanco

cualquier dígito

cualquier cosa que no sea un dígito

inicio o final de palabra

comienzo

final (incluido salto de línea)

Final

Ejemplos de expresiones regulares POSIX extendido 1.- La expresión siguiente sirve para verificar un eMail correctamente escrito: "/^([a-zA-Z0-9])+([a-zA-Z0-9\._-])*@([a-zA-Z0-9_-])+([a-zA-Z0-9\._-]+)+$/" o más sencilla /^(.+\@.+\..+)$/ Explicación.- Comienza (^) por caracteres cualesquiera que no sean salto de línea (.) de los que habrá al menos una ocurrencia (+), después el carácter arroba (\@), seguido de al menos un carácter que no podrá ser el salto de línea (.+), después viene el carácter punto (\.), seguido de al menos un carácter donde ninguno podrá ser el salto de línea (.+), y aquí acabará la cadena ($). 2.- Si queremos verificar que un password es seguro escribiríamos "/^.*(?=.{8,})(?=.*\d)(?=.*[a-z])(?=.*[A-Z]).*$/" 3.- Verificar un número telefónico en USA

"/([0-9]{4})\/([0-9]{2})\/([0-9]{2})/i","$3/$2/$1" Verificar un número telefónico en españa, sin espacios y con código internacional 61

/^$\+\d{2,3}$\d{9}$/ Explicación.- Comienza (^) por un paréntesis ($), le sigue un carácter + (\+), después una cifra numérica (\d) de la que habrá 2 o 3 ocurrencias ({2,3}), después le sigue un paréntesis de cierre ($), luego viene una cifra numérica de la que habrá 9 ocurrencias ({9}), y aquí acabará la cadena ($). NOTA: Puesto que los caracteres: (, ), +, *, -, \, {, }, |, etc… tienen significados especiales dentro de una expresión regular, para considerarlos como caracteres normales que debe incluir una cadena deben de ir precedidos del carácter de barra invertida \. 4.- Verificar un código postal /^\d{5}$/ Únicamente contiene 5 cifras numéricas 5.- Verificar fecha en format dd/mm/aaaa /^\d{2}\/\d{2}\/\d{4}$/ Comienza (^) por una cifra numérica (\d) de la que habrá 2 ocurrencias ({2}), después una barra (\/), seguida de 2 cifras numéricas, otra barra, 4 cifras numéricas, y aquí acabará la cadena ($).

Mas ejemplos: Patrón

Cadena ¿Cumple?

Comentario

awbwc

Los caracteres tienen que estar seguidos.

34abc

Sí

No importa que hayan caracteres antes...

cbabcba

Sí

... o después.

a2b

g1da2b3

Sí

Las expresiones regulares detectan letras, números, ...

áb

3áb4

Sí

... incluso acentos, ...

a\$b

1a$b2

Sí

... salvo los caracteres ^ . [ $ ( ) | * + ? { \ € que deben llevar una contrabarra \ antes, además de \n (nueva línea) y \t (tabulador)

bic

Sí

Los corchetes definen los caracteres admitidos en una posición ...

bcd

bic

Sí

aei

avr

Sí

av1

abc

[aeiou]

[^aeiou]

[p-t]

... o no admitidos

Se pueden definir rangos de caracteres...

[B-D]

[0-9]

PMD

Sí

AV1

b9d

Sí

bcd

... en minúsculas o mayúsculas ...

... o números

[[:alpha:]]

Cualquier carácter alfabético (sin acentos)

[[:digit:]]

Cualquier número

[[:alnum:]]

Cualquier número o carácter alfabéticos (sin acentos)

[[:punct:]]

Cualquier carácter que no sean letras y números (menos el euro)

[[:space:]]

Cualquier tipo de espacio en blanco

[[:upper:]]

Cualquier mayúscula (sin acentos)

[[:lower:]]

Cualquier minúscula (sin acentos)

^ab

ab$

^ab$

ab?c

a.c

ab+c

cab

Los caracteres tienen que estar al principio

abc

Sí

No importa que hayan caracteres después

abc

Los caracteres tienen que estar al final

cab

Sí

No importa que hayan caracteres antes

Sí

Tiene que empezar y acabar por aba ...

abab

... y no puede haber nada antes o después

abcde

Sí

El carácter b puede estar entre a y c...

acde

Sí

... o no estar entre a y c ...

adcde

... pero no puede haber otro carácter

abc

Sí

El . representa cualquier carácter ...

Sí

... incluso el espacio el blanco, ...

abdc

pero sólo un carácter

abcde

Sí

El carácter b puede estar una vez...

abbbcde

Sí

... o varias ...

acde

... pero tiene que estar al menos una vez.

abcde

Sí

El carácter b puede estar una vez...

abbbcde

Sí

... o varias ...

acde

Sí

... o ninguna.

abbbc

Sí

Las llaves indican el número exacto de repeticiones del carácter, ...

abbbbc

... no puede haber más ...

abbc

... ni menos.

abc

Se pueden definir rangos con límite inferior e inferior

abbc

Sí

abbbc

Sí

abbbbc

Sí

abbbbbc

ab{2,}c

abc

Se pueden definir rangos sin límite superior

a(bc){2}d

abcbcd

Sí

Los paréntesis definen agrupaciones de caracteres. En este caso bc tiene que aparecer repetido

abcd

Sí

Aquí bc puede estar ...

Sí

... o no estar, ...

abd

... pero no puede aparecer sólo la b, o sólo la c u otro carácter

abc

Sí

Entre la a y la c puede estar el carácter b...

adc

Sí

... o el carácter d, ...

abdc

... pero no los dos, ...

... ni ninguno de ellos.

abc

Sí

Está la pareja ab ...

adc

Sí

... o dc ...

abdc

Sí

... o las dos, ...

ab*c

ab{3}c

ab{2,4}c

a(bc)?d

a(b|d)c

^(ab)|(dc)$

^(ab)$|^(dc)$

... pero no ninguna

abc

Está la pareja ab, pero sobra la c ...

adc

... o está la pareja dc, pero sobra la a.

Sí

Está una de las dos

DATOS y VARIABLES en R Variables y asignación Los distintos tipos de datos pueden almacenarse en variables que se identifican con un nombre. Los nombres de variables deben comenzar por una letra seguida de más letras, dígitos o los caracteres punto (.) o subrayado (_). Se diferencia entre mayúsculas y minúsculas. Los nombres de las variables deben ser informativos utilizando por convenio el punto "." para separar distintas palabras. Para almacenar datos en una variable se utiliza el operador de asignación <También se puede utilizar el signo "=" pero no es aconsejable porque el signo "=" tiene otras funciones que desconsejan su uso para asignar por motivos de comprensión del código. > mi.variable.numerica <- 3.524 > mi.variable.caracter <- "control" > mi.variable.booleana <- TRUE > assing("x", 4) > .last.value

Asigna 3.524 a la variable mi.variable.numerica Asigna "control" a la variable mi.variable.caracter Asigna TRUE a la variable mi.variable.booleana Equivalente a "x <- 4" , es decir es la función asignar Función que presenta el último comando ejecutado

Tipos de datos Existen varias clases de datos en R, vamos a ver inicialmente 4 •

números (numeric) o

enteros (integer)

doble precisión (double)

complejos (complex)

•

caracter (character)

•

lógicos (logical)

•

nulo NA o valor missing

•

factores (factor)

•

vectores

•

matrices

•

listas

•

data frames 66

Datos numéric R maneja tres tipos de datos numéricos o

enteros (integer)

reales (real)

complejos (complex)

Salvo aplicaciones muy especiales usaremos siempre datos reales hemos visto en la sección de introducción > x <- 3.524 >x > 7.28 -> x >x > class(x)

con las operaciones que

Asigna a x el valor 3.524 [1] 3.524 También se puede asignar hacia la derecha [1] 7.28 Nos indica el tipo de variable que usamos [1] "numeric"

Datos Character (strings) Son los que son tratados como entradas alfanumericas: fechas, nombres y apellidos de personas, cualquier texto. Los datos character se introducen y se muestran entre comillas. > c1<- "cafe" > c2<- "con" > c3<- "leche" > paste(c1,c2,c3) > paste(c1,c2,c3,sep="#") > z <- paste(c1,c2,c3,sep="%") >z > class(z) > substr(z,6,8)

\n \t > paste("Papa","Noel",sep=" ") > paste(c("X","Y"),1:2,sep="")

> paste(c("X","Y"),1:4,sep=".")

>paste(c("X","Y"),1:4,sep=".", collapse="-")

Creo tres variable character c1 c2 y c3 asignándoles los valores "cafe" "con" "leche" Concatena c1 c2 y c3. El separador por deecto es espacio " " [1] "cafe con leche" Pero podemos establecer cualquier separador [1] "cafe#con#leche" Y asignarlo a una variable z con separador "%" [1] "cafe%con%leche" Nos informa de la clase de la variable z [1] "character" Importante función que extrae de la variable z las posiciones de la 6 a la 8 [1] "con" Es el caracter salto de líne Es el caracter tabulador Concatena dos o más valores characters [1] "Papa Noel" Concatena dos vectores el X Y y el 1 2 componente a componente y el separador es ninguno "" por lo que presenta el vector character siguiente [1] "X1" "Y2" Concatena el vector X Y con el 1 2 3 4 con el separador "." por lo que tiene que repetirlo 2 veces, obteniendo [1] "X.1" "Y.2" "X.3" "Y.4" El collapse "-" sirve para concatenar todos los elementos del vector en uno solo con el "-" 67

> length(paste(c("X","Y"), 1:4, sep=".",collapse="-")) > strsplit("03-21-2015",split="") > cut( ) > nchar("Papa Noel") > grep("Noel",c("Santa","Papa Noel","Noel Garcia Bernal") > match > i <- 2 > sprintf("El cuadrado de %d es %d",i,i^2) > pmatch > tolower > toupper > sub > gsub > regexpr["iss","Mississippi")

[1] "X.1-Y.2-X.3-Y.4" Que tras concatenarlos tiene un solo elemento [1] 1 Divide un character en un vector de varios acorde al separador especificado [[1]] [1] "03" "21" "2015" Devuelve la longitud del string [1] 9 Devuelve que vectores contienen el patron "Noel" [1] 2 3 Ensambla un string por partes de una manera formateada [1] " El cuadrado de 2 es 4"

Devuelve la primera posiciín del patrón "iss" en el character "Mississippi" [1] 2 Devuelve las posiciones del patrón "iss" en el character > gregexpr["iss","Mississippi") "Mississippi" [[1]] [1] 2 5 Es posible que opines que estas funciones no son suficientes lo bastante para trabajar cómodamente en programación. No lo niego. Pero tiene solución Y la solución se llama paquete 'stringr' que incluye auténticas maravillas como búsqueda de patrones de secuencias y mucho más, vamos a dar una introspectiva Claro que esto implica un sacrifico y es que tienes que aprender lenguaje PERL y saber trabajar con "expresiones regulares" > library(stringr)

Carga la libreria stringr

Str_c > a <"00010111110010101011101001111 01101001" > b <"10101000011110101011100101" > str_detect(a, "01001") > str_extract(a, "01001") > str_detect(b, "01001") > str_extract(b, "01001")

Junta multiples strings en uno

> str_locate(a, "01001")

[1] TRUE [1] NA [1] FALSE [1] "01001" Nos devuelve la posición encuentra el patron "01001" start end [1,] 22 26

donde

> > > > >

Devuelve la longitud en caracteres del string [1] 37 [1] 26

str_length(a) str_length(b) a <- " Hola que tal " str_trim(a, side = "both") str_trim(a, side = "both")

> fruit <- c("apple", "pear", "pinapple")

[1] "Hola que tal" "banana",

Detecta la presencia o ausencia de un patron dentro de un string

> str_detect(fruit, "a") > str_detect(fruit, "^a") > str_detect(fruit, "a$") > str_detect(fruit, "b") > str_detect(fruit, "[aeiou]") > shopping_list <- c("apples x4", "flour", "sugar", "milk x2") > str_extract(shopping_list, "\\d") > str_extract(shopping_list, "[a-z]+") > str_extract(shopping_list, "[az]{1,4}") > str_extract(shopping_list, "\\b[az]{1,4}\\b") > fruits <- c( "apples and oranges and pears and bananas", "pineapples and mangos and guavas" )

[1] TRUE TRUE TRUE TRUE [1] TRUE FALSE FALSE FALSE [1] FALSE TRUE FALSE FALSE [1] FALSE TRUE FALSE FALSE [1] TRUE TRUE TRUE TRUE Devuelve la primera pieza que encaja con el patron (se puede dar en expresion regular) [1] "4" NA NA "2" [1] "apples" "flour" "sugar" "milk" [1] "appl" "flou" "suga" "milk"

> str_split(fruits, " and ")

[[1]] [1] "apples" "oranges" "pears"

> hw <- "Hadley Wickham" > str_sub(hw, 1, 6) > str_sub(hw, end = 6) > str_sub(hw, 8, 14) > str_sub(hw, 8) > str_sub(hw, c(1, 8), c(6, 14)) > str_sub(hw, -1) > str_sub(hw, -7) > str_sub(hw, end = -7) > str_sub(hw, seq_len(str_length(hw)))

> str_sub(hw, end = seq_len(str_length(hw)))

[1] NA

"milk"

Esta funcion descompone un string segun un patr贸n

"bananas"

[[2]] [1] "pineapples" "mangos" "guavas" Extrae substrings de un string dado [1] "Hadley" [1] "Hadley" [1] "Wickham" [1] "Wickham" [1] "Hadley" "Wickham" [1] "m" [1] "Wickham" [1] "Hadley W" [1] "Hadley Wickham" "adley Wickham" "dley Wickham" "ley Wickham" [5] "ey Wickham" "y Wickham" " Wickham" "Wickham" [9] "ickham" "ckham" "kham" "ham" [13] "am" "m" [ 1] "H" "Ha" "Had" "Hadl" [5] "Hadle" "Hadley" "Hadley " "Hadley W" [9] "Hadley Wi" "Hadley Wic" "Hadley Wick" "Hadley Wickh" [13] "Hadley Wickha" "Hadley Wickham" 69

> sentences <- c("Jane saw a cat", "Jane sat down") > word(sentences, 1) > word(sentences, 2) > word(sentences, -1) > word(sentences, 2, -1)

Extrae palabras de una frase

> > word(sentences[1], 1:3, -1) > word(sentences[1], 1, 1:4)

# Y también vectoriza [1] "Jane saw a cat" "saw a cat" "a cat" [1] "Jane" "Jane saw" "Jane saw a" "Jane saw a cat" Extrae la primera coincidencia del pattern en el string Extrae un vector con las posiciones de coincidencia del pattern en el string Reemplaza la primera coincidencia del pattern en el string con replacement Reemplaza todas las pcoincidencias del pattern en el string con replacement

> str_match(string,pattern) > str_match.all(string,pattern) > str_replace( string, pattern, replacement) > str_replace.all( string, pattern, replacement) Y hay más !!! (ver manual)

[1] [1] [1] [1]

"Jane" "Jane" "saw" "sat" "cat" "down" "saw a cat" "sat down"

Datos de números complejos Al ser de uso casi exclusivod e Matemáticas los obviaremos en llo posible y, para equilibrar la situación, introduciremos otros más útiles para nuestro propósito de investigación financiera

Datos Fecha (date) La manipulación de fechas no está eincluída en el modulo base o CORE de R. No soy capaz de entenderlo, porque siempre resulta necesario utilizar manipulaciones y ordenaciones por fecha, no ya en series temporales, sino en casi cualquier propósito. Lo que si incluye el CORE es la fecha y hora del sistema

> date() Sys.time() Sys.Date() > op <- options(digits.secs = 6)

> Sys.time() > options(op) > format(Sys.time(), "%a %b %d %X %Y") > format(Sys.time(),"%b %d %Y")

[1] "2015-03-28 18:13:11.114907 CET" locale-specific version of date() [1] "sá. mar. 28 18:13:11 2015"

> format(Sys.time(),"%b%d%Y")

[1] "mar.282015"

[1] "mar. 28 2015"

Como no está en el base, nos vemos obligados a instalarlo desde el repositorio y después:

> library(date) > mydate <- "01/20/1957" > x <- as.date(mydate, order = "mdy") > x.nac <- as.date("01/20/1957") > x.hoy <- as.date("03/28/2015") > x.hoy - x.nac > > > > > > > > > > >

x <- 16810 is.date (x) x <- mdy.date(1,10,2000) is.date (x) mydate is.date(mydate) mydate <- as.date(mydate) is.date(mydate) x.2000 <- mdy.date(1,1,2000) x.2000 x.2000 +7

> date.mmddyyyy(14610) > date.mmddyyyy(14623) > date.mmddyyyy(14623,sep="-") > date.ddmmyyyy(14623,sep="-") > date.ddmmmyy(1:10)

> date.ddmmmyy(14610) > date.mdy(14610:14617)

> date.mdy( 14610:14617, weekday = T)

> x <- mdy.date(1,10,2000) > 14630 - x > Math.date(mydate)

Asignamos la fecha '20 Ene 1957' a mydate en formato americano "mm/dd/yyyy" Convierte mydate en juliano [1] 20Jan57 Asigno a x.nac fecha de naciomiento Asigno a x.hoy fecha de hoy (formato americano) Nos da la diferencia de días [1] 21251 Devuelve T or F si x es objeto fecha [1] FALSE [1] TRUE [1] "01-20-1957" [1] FALSE [1] TRUE Convierte a Juliano (internamente numérico,a quneu lo presente como fecha) [1] 1Jan2000 [1] 8Jan2000 Dada una fecha en juliano nos la devuelve en formato "mm/dd/aaaa" [1] "1/1/2000" [1] "1/14/2000" [1] "1-14-2000" Dado un vector numerico (Juliano) nos devuelve un vector en formato "20Jan57" [1] "2Jan60" "3Jan60" "4Jan60" "5Jan60" "6Jan60" "7Jan60" "8Jan60" [8] "9Jan60" "10Jan60" "11Jan60" [1] "1Jan2000" Dado un vector en Juliano nos lo descompone en una lista de valores separados dd mmm yy y opcionalmente weekday: $month [1] 1 1 1 1 1 1 1 1 $day [1] 1 2 3 4 5 6 7 $year [1] 2000 2000 2000 2000 2000 2000 2000 2000 $month [1] 1 1 1 1 1 1 1 1 $day [1] 1 2 3 4 5 6 7 8 $year [1] 2000 2000 2000 2000 2000 2000 2000 2000 $weekday [1] 7 1 2 3 4 5 6 7 Convierte una fecha en Juliano, aunque la presente . Ahora podemos operar aritméticamente con ella [1] 11 Aunque viene en el índice del autor, estas funciones 71

> as.character.date(mydate)

dan Error a fecha de hoy (Marzo 2015)

Datos missing NA y NaN En R los valores desconocidops no disponibles NA (Not Available) se simbolizan con NA, Cualquier operación que incluya un solo valor NA entre sus integrantes, devolverá como resultado el valor NA También existe el valor NaN (Not a Number) que surgen en operaciones numéricas por ejemplo en la división por cero, ó en 0/0 Y también se contempla el caso de valor infinito > x <- c(1:2,NA) >x > is.na(x) > 0/0 > is.na(x) > is.nan (x) > is.infinite(-5/0) > is.na (5/0)

[1] 1 2 NA [1] FALSE FALSE TRUE [1] NaN Nos dice si x es NA o NaN Funciona solo para los NAN [1] TRUE [1] FALSE

Para "modelling functions" (ejemplo lm( ) ) lo mejor es usar • na.omit • na.exclude Esta última más idónea para generar predicciones, resíduos También existe una función que elimina todos los NA, por ejemplo > XNA <- matrix(c(1,2,NA,3,NA,5), nrow=3) > XNA

> X.no.na <- na.omit(XNA) > X.no.na

[,1] [,2] [1,] 1 3 [2,] 2 NA [3,] NA 5 [,1] [,2] [1,] 1 3 attr(,"na.action") [1] 3 2 attr(,"class") [1] "omit"

Datos Factor Los factores mson semejantes a alos caracter pero hay una diferencia basica y es que factores suelen ser muy pocos y nos suele interesar guardar registro de cuales son.

sus

Loa valores sexo, raza, tipo de estudios, mes de nacimiento, ... son típicos datos factor. 72

factor (vector, ordered=T 贸 F, labels= ) > factor() > is.factor() > level() > table() > x<-c("A","B","C","A","C","A","C") >x > class(x) > as.factor(x) > fx<- as.factor(x) > fx > levels(x) > table(fx) > fx > gl(n,k,length= ) > ordered( c("alto","bajo","medio","alto","alto","b ajo","alto"), levels=c("bajo","medio","alto") > ff<c("alto","bajo","medio","alto","alto","b ajo","alto") > as.factor(ff) > factor(ff) > gl(2,1,20) > gl(2,2,20)

[1]"A" "B" "C" "A" "C" "A" "C" [1] "character"

[1] A B A C A C levels: A B C [1] "A" "B" "C" [1] A B C 312 Genera un factor de n niveles repetidos cada uno k veces [1] alto bajo medio alto alto bajo alto Levels: bajo < medio < alto

[1] alto bajo medio alto alto bajo alto Levels: alto bajo medio [1] 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 Levels: 1 2 [1] 1 1 2 2 1 1 2 2 1 1 2 2 1 1 2 2 1 1 2 2 Levels: 1 2

Datos logical Suelen ser factores que tienen dos posibles niveles TRUE y FALSE Conectiva AND & Conectiva OR

Conectiva NOT !

(la conjunci贸n booleana) (la disyunci贸n booleana) (la negaci贸n booleana)

> is.logical() > p<-TRUE > q<-FALSE > p|q [1] TRUE > p&q [1] TRUE > p%!q > is.logical(p) [1] TRUE 73

> x<-c(1,2,3,11,20,30) > class(x) [1] "numeric" > x>10 [1] FALSE FALSE FALSE TRUE TRUE TRUE > sum(x>10) [1] 3

R hace una equivalencia entre TRUE y 1 y entre FALSE y 0

como el TRUE es 1 y hay 3 componentes > 10

Coerción de tipos Como todos los lenguajes d eprogramación, se pueden transformar los tipos de datos de unos a otros, si lo necesitásemos. Para ello, Las funciones más usuales son • • • • • • •

as.caracter as.integer as.double as.compelx as.numeric as.logical as.factor

> x <- c(1,2,3) >x > class(x) > y <- as.character(x) >y > x <- c("1","2","A") >x > class(x) > x <- as.numeric(y) >x > x <- c(1,"A",2)

> class(x) >x > x <- 1:4 +i >x

Asigno a x el vector numerico de componentes 1 2 y 3 [1] 1 2 3 [1] "numeric" [1] "1" "2" "3" Asigno a x el vector character 1 2 A [1] "1" "2" "A" [1] "character" Convierto el vector y en un vector numerico, y le asigna NA a la componente tercera A por no ser originalmente numérica [1] 1 2 NA Asigna al vector x las componentes 1 "A" y 2, que son mezcla numeric y character. R convierte entonces, todos a character de forma coarcitiva [1] "character" [1] "1" "A" "2" Asigna a x un vector de numeros complejos que empiezan en 1+1i hasta 4+1i [1] 1+1i 2+1i 3+1i 4+1i

Estructuras de Datos compuestos R soporta varios tipos de datos compuestos. En este tutorial sólo hablaremos de •

vectores (vector)

•

matrices (matrix) 74

•

marcos (dataframe)

Vectores Vectores son coleccciones unidimiensionales descomponerse en mas partes

objetos

atómicos

que

pueden

Pueden contener numeros caracteres factores o valores logicos , pero todos de la misma clase y si no lo son R los convierte en la misma clase

> datos.consecutivos <- 1:10 > datos.consecutivos [1] 1 2 3 4 5 6 7 8 9 10 > datos <- c(2,1,3,-1,10,0,0,1) > datos [1] 2 1 3 -1 10 0 0 1 > datos[1] [1] 2

Para crear un vector que consista en una serie de número consecutivos se utiliza el operador : Para crear un vector usamos la función c( ) que significa concatenación. Cada dato recibe un índice según el orden en el que se concatenó (comenzando por 1)

> datos[c(1,3,5)] [1] 2 3 10 > datos>1 [1] TRUE FALSE TRUE FALSE TRUE FALSE FALSE FALSE > datos[datos > 1]

Nos da las posiciones 1 del vector datos Nos da las posiciones 1 3 y 5 del vector datos Seria una respuesta lógica componentes que son > 1

aquellas

Nos dice que componentes son mayores que 1

Otros ejemplos con vectores > x <- c(1,2,3) > class(x) [1] "numeric" > x <- (1, 2, "3") >x [1] "1" "2" "3"

> w <- c(TRUE,TRUE,FLASE) > class(w) [1] "logical" > x <- (1,2,3,4,5,6,7,8,9,10) >x [1] 1 2 3 4 5 6 7 8 9 10 > x[3] [1] 3 > x[-3] [1] 1 2 4 5 6 7 8 9 10 > x[c(5,6)] [1] 5 6 > x[1:3] > x[x>6]

Introducimos un vector numérico de 3 componentes Todas las componentes del vector deben ser del mismo tipo. Si hay numericas y character los convierte todos a character Creamos w un vector lógico Crea un vector de 10 componentes numericas Nos da del vector x el que ocupa la posicion 3 Nos da todos menos el 3 nos da los que ocupan la posicion 5 y 6 nos da las posiciones de la 1 a la 3 Nos da las posiciones de x que son mayores que 6 75

> n <- 10 > v <- 1:n >v > v <- 1:n-1 >v > v <- 1:(n-1) >v > seq(1,10,by=2) > seq(1,10,length=3) > seq(1,10,length=3,by=2)

Asigna 10 a la variable n Asigna los valores 1 a 10 al vector v Expresa en pantalla el vector v [1] 1 2 3 4 5 6 7 8 9 10 La colacación del "-1" hace que en lugar de 1 a 10 sea de 0 a 9 [1] 0 1 2 3 4 5 6 7 8 9 En cambio aquí los paréntesis provocan que sea de 1 a9 [1] 1 2 3 4 5 6 7 8 9 Secuencia de valores de 1 a 10 pero de 2 en 2 [1] 1 3 5 7 9 Al decirle length =3 R establece la razón de la progresion [1] 1.0 5.5 10.0 Nos da un error por la incongruencia de la expresión Error en seq.default(1, 10, length = 3, by = 2) : too many arguments

Subvectores de un vector > x<--2:2 >x > names(x)<-letters[1:5] >x

> x[c(2,4)] > x[1:3] > x[1:3-1]

> x[1:(3-1)] > x[-c(2,4)] > x[x>0]

> x[c("a","d"]

> x <- 1:n-1

Nos da un vector x de 5 componentes [1] -2 -1 0 1 2 Nombra cada una de las componentes de x con las 5 primeras letras [1] a b c d e -2 -1 0 1 2 Nos escribe la 2 y la 4ª componente de x [1] -1 1 Nos escribe las tres primeras componentes de x [1] -2 -1 0 Nos escribirá las posiciones 0 1 2 del vector. Como, además, la posición 0 no existe, nos devuelve [1] -2 -1 Nos escribire las posiciones 1 2 del vector. [1] -2 -1 Nos escribe todo x excepto las componentes 2 y 4 [1] -2 0 2 Nos escribe las componentes de x que verifican la condición x>0 [1] 1 2 Como las componentes de x tienen nombre, nos escribe las componentes a y d [1] -2 1 Si 1:n es (1 2 3 ... n) entonces 1:n-1 es (0 1 2 ....n-1) [1]

Indexación de un vector > v <- c(1:3,NA,4:8,NA,9,10) >v > v[!is.na(v)]

Asigno al vector v la concatenación dada [1] 1 2 3 NA 4 5 6 7 8 NA 9 10 ! significa no is.na es la funcion que asigna el valor NA Esta función nos devuelve de v todo aquello que no es 76

> > >

NA [1] 1 2 3 4 5 6 7 8 9 10 v[!is.na(v) & v%%2==0] Algo mas complejo Del vector previo condiciona ademas a que v modulo 2 sea 2, es decir par: [1] 2 4 6 8 10 v[1:5] Las cinco primeras componentes de v [1] 1 2 3 4 5 v[c(1,3,5,7,9,11)] Las posiciones de v (el inicial) impares [1] 1 3 4 6 8 9 v[-(1:5)] Del vector v elimina los 5 primeros, resultando [1] 5 6 7 8 NA 9 10 v <- c(1,2,3,NA) Asigno al vector v los valores 1 2 3 NA names(v) <- c("uno", "dos", Asigno a cada componente de v un nombre

> > "tres", "cuatro") > v[c("dos","tres")]

> v[is.na(v)] <- 0 >v > v[v>2] <- -v[v>2] >v > v <- c(1:3,NA,4:8,NA,9,10) > rev(v) > sort(v) sort (v, decreasing = T) > > > >

w <-c("X","A","R","F") w sort(w) sort (w, decreasing = T)

Ahora podemos consultar componentes por nombre dos tres 2 3 Sustituye los NA por 0 uno dos tres cuatro 1 2 3 0 Cambia el signo a los valores superiores a 2 del vector uno dos tres cuatro 1 2 -3 0 Cambia el orden de los vectores [1] 10 9 NA 8 7 6 5 4 NA 3 2 1 Ordena las componentes (por defecto ascendente) y los NA se omiten [1] 1 2 3 4 5 6 7 8 9 10 Ordena por orden decreciente [1] 10 9 8 7 6 5 4 3 2 1 Lo mismo ocurre con alfanumĂŠricos [1] "X" "A" "R" "F" [1] "A" "F" "R" "X" [1] "X" "R" "F" "A"

Ordenacion de vectores > x<- c(4,1,9,2) > order(x) > order (-x) > order (x, decreasing = T) > sort(x) > sort(x, decreasing = T) > sort(-x) > rev(x) > rank(x) > x[order(x)] > y <- c(1,2,2,3,3,4) > rank (y) > min(y)

[1] 2 4 1 3 [1] 3 1 4 2 [1] 3 1 4 2 [1] 1 2 4 9 [1] 9 4 2 1 [1] -9 -4 -2 -1 [1] 2 9 1 4 [1] 3 1 4 2 [1] 1 2 4 9 [1] 1.0 2.5 2.5 4.5 4.5 6.0 [1] 1 77

> max(y) > which.min(y) > which.max(y)

[1] 4 [1] 1 [1] 6

> z <- c(1, 1, 2, 2) > order(z, x)

[1] 2 1 4 3

Matrices Una matriz es una colección de datos del mismo tipo que tiene dos dimensiones. Para crear una matriz usamos la función matrix. Los elementos se proporcionan en un vector y se colocan por columnas: > = > > = > >

M <- matrix(1:10, nrow = 2, ncol 5) M M <- matrix(1:10, nrow = 2, ncol 5, byrow=TRUE) M dim(M)

> nrow(M) > ncol(M) > rownames(M) <- c("fila1", "fila2") > colnames(M) <- c("columna1", "columna2", "columna3", "columna4", "columna5") >M > M[1,2] > M["fila2","columna2"] > M[1,] > M[,"columna3"]

Si queremos que se rellene por filas es necesario especificar el argumento byrow = TRUE: La función dim devuelve las dimensiones de una matriz La función nrow devuelve el número de filas La función ncol devuelve el número de columnas Podemos asignar nombres a las filas y las columnas de una matriz

Podemos seleccionar un elemento por el nombre de su fila y su columna: Podemos extraer filas y columnas enteras como vectores de matrices utilizando sólo el primer o segundo índice respectivamente y dejando el segundo en blanco

Creando y dando valores a matrices > a1<-c(1,2,3,4) > a2<-(5,6,7,8) > a3<-(9,10,11,12) > a<-c(a1,a2,a3) >a

Crea un vector a1 de cuatro componentes (1,2,3,4) Crea un vector a2 de cuatro componentes (5,6,7,8) Crea un vector a3 de cuatro componentes (9,10,11,12) Concatena "c" los vectores a1 a2 y a3 en un nuevo vector a [1] 1 2 3 4 5 6 7 8 9 10 11 12 funcion bind (unir) cbind = cada VECTOR pasa a ser cada COLUMNA (colum) rbind = cada VECTOR pasa a ser cada FILA (row) 78

> ma<-cbind(a1,a2,a3) > ma

> dim (ma) > ma<-matrix(a,ncol=3,byrow=F)

> ma<-matrix(a,ncol=3) > ma

> ma<-matrix(a,nrow=3) > ma

> ma<-matrix(a,nrow=3,byrow=T) > ma

cbind pasa cada vector a1 a2 a3 a vectores columna de a a1 a2 a3 [1,] 1 5 9 [2,] 2 6 10 [3,] 3 7 11 [4,] 4 8 12 nos dice las dimensiones de la matriz ma [1] 4 3 construye matriz ma â&#x20AC;˘ a es el vector â&#x20AC;˘ ncol es el num de columnas o nrow num de filas â&#x20AC;˘ byrow datos ordenados por filas si es T(true) o por columnas si es F(false). Se puede omitir [,1] [,2] [,3] [1,] 1 5 9 [2,] 2 6 10 [3,] 3 7 11 [4,] 4 8 12 [,1] [,2] [,3] [,4] [1,] 1 4 7 10 [2,] 2 5 8 11 [3,] 3 6 9 12 [,1] [,2] [,3] [,4] [1,] 1 2 3 4 [2,] 5 6 7 8 [3,] 9 10 11 12

Otra forma mas directa de construir una matriz es > ma<-matrix(a,4,3) > ma

> ma<-matrix(a,3,4) > ma

[,1] [,2] [,3] [1,] 1 5 9 [2,] 2 6 10 [3,] 3 7 11 [4,] 4 8 12 [,1] [,2] [,3] [,4] [1,] 1 4 7 10 [2,] 2 5 8 11 [3,] 3 6 9 12

Otra manera de construir una matriz a partir de un vector a es mediante el comando dim > dim(a)<-c(4,3) >a

que coincide con la forma anterios pero el vector a ha quedado transformado [,1] [,2] [,3] [1,] 1 5 9 [2,] 2 6 10 [3,] 3 7 11 [4,] 4 8 12

La cuarta forma de leer una matriz es introducir los nĂşmeros por teclado previo comando scan() > ma<- 1: 1 5 9 matrix(scan(),ncol=3,byrow=T) 4: 2 6 10 7: 3 7 11 10: 4 8 12 13: aqui pulsamos enter Read 12 items > ma [,1] [,2] [,3] [1,] 1 5 9 [2,] 2 6 10 [3,] 3 7 11 [4,] 4 8 12 > ma<- Si los queremos introducir por filas matrix(scan(),nrow=3,byrow=T) 1: 1 2 3 4 5: 5 6 7 8 9: 9 10 11 12 13: Read 12 items > ma [,1] [,2] [,3] [,4] [1,] 1 2 3 4 [2,] 5 6 7 8 [3,] 9 10 11 12

Nombrar las filas y columnas Parea ponerles nombres a las columnas (usamos NULL para las filas y asi solo nombra columnas) > dimnames(ma) <- list(NULL, c( enero febrero marzo "enero", "febrero", "marzo")) [1,] 1 5 9 [2,] 2 6 10 > ma [3,] 3 7 11 [4,] 4 8 12 Tambien podriamos haber nombrado primero las columnas con nomcol > nomcol <- c("enero", "febrero", "marzo") > dimnames(ma) <-list( NULL,nomcol) > ma

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

enero febrero marzo 1 5 9 2 6 10 3 7 11 4 8 12

Por Ăşltimo podriamos en lugar de NULL haber hecho lo mismo para las filas y tendriamos > nomfila<-c("fila 1", "fila 2", "fila 3", "fila 4") > dimnames(ma)<list(nomfila,nomcol) > ma

enero febrero marzo fila 1 1 5 9 fila 2 2 6 10 fila 3 3 7 11 fila 4 4 8 12

Se puede hacer todo junto a la vez 80

> mb<matrix(a,nrow=4,byrow=F,dimna mes=list(c("fila 1", "fila 2", "fila 3"), nomcol)) > mb

enero febrero marzo fila 1 1 5 9 fila 2 2 6 10 fila 3 3 7 11 fila 4 4 8 12

Otra matriz por filas seria > ma<-matrix(a,nrow=3,byrow=T, dimnames=list(c("fila 1", "fila 2", "fila 3"),c("enero", "febrero", "marzo", "abril")) > mb

enero febrero marzo abril fila 1 1 4 7 10 fila 2 2 5 8 11 fila 3 3 6 9 12

TambiĂŠn se pueden subindicar las filas y columnas. Pongamos ejemplos con otra matriz > x<-1:100 > xa<-matrix(x,20) > xa

> rownames(xa)<rownames(xa,do.NULL=F,prefix= "Fila.") > xa

[,1] [,2] [,3] [,4] [,5] [1,] 1 21 41 61 81 [2,] 2 22 42 62 82 [3,] 3 23 43 63 83 [4,] 4 24 44 64 84 [5,] 5 25 45 65 85 [6,] 6 26 46 66 86 [7,] 7 27 47 67 87 [8,] 8 28 48 68 88 [9,] 9 29 49 69 89 [10,] 10 30 50 70 90 [11,] 11 31 51 71 91 [12,] 12 32 52 72 92 [13,] 13 33 53 73 93 [14,] 14 34 54 74 94 [15,] 15 35 55 75 95 [16,] 16 36 56 76 96 [17,] 17 37 57 77 97 [18,] 18 38 58 78 98 [19,] 19 39 59 79 99 [20,] 20 40 60 80 100 Este comando subindica las filas [,1] [,2] [,3] [,4] [,5] Fila.1 1 21 41 61 81 Fila.2 2 22 42 62 82 Fila.3 3 23 43 63 83 Fila.4 4 24 44 64 84 Fila.5 5 25 45 65 85 Fila.6 6 26 46 66 86 Fila.7 7 27 47 67 87 Fila.8 8 28 48 68 88 Fila.9 9 29 49 69 89 Fila.10 10 30 50 70 90 Fila.11 11 31 51 71 91 Fila.12 12 32 52 72 92 Fila.13 13 33 53 73 93 Fila.14 14 34 54 74 94 Fila.15 15 35 55 75 95 81

> colnames(xa)<-paste("mes", seq(1,dim(xa)[2]), sep="") dim(xa)[2] corresponde a las columnas dim(xa)[1] corresponde a las filas > xa

Fila.16 16 36 56 76 96 Fila.17 17 37 57 77 97 Fila.18 18 38 58 78 98 Fila.19 19 39 59 79 99 Fila.20 20 40 60 80 100 Este comando subindica las columnas mes1 mes2 mes3 mes4 mes5 Fila.1 1 21 41 61 81 Fila.2 2 22 42 62 82 Fila.3 3 23 43 63 83 Fila.4 4 24 44 64 84 Fila.5 5 25 45 65 85 Fila.6 6 26 46 66 86 Fila.7 7 27 47 67 87 Fila.8 8 28 48 68 88 Fila.9 9 29 49 69 89 Fila.10 10 30 50 70 90 Fila.11 11 31 51 71 91 Fila.12 12 32 52 72 92 Fila.13 13 33 53 73 93 Fila.14 14 34 54 74 94 Fila.15 15 35 55 75 95 Fila.16 16 36 56 76 96 Fila.17 17 37 57 77 97 Fila.18 18 38 58 78 98 Fila.19 19 39 59 79 99 Fila.20 20 40 60 80 100

Volviendo a nuestra matriz ma , la redefinimos > ma<-matrix(a,4,3) > ma

> colnames(ma)<-nomcol > rownames(ma)<-nomfila > ma

> a<-1:15 > m<-matrix(a,5,3) >m

> t(m)

> m[2,3]

[,1] [,2] [,3] [1,] 1 5 9 [2,] 2 6 10 [3,] 3 7 11 [4,] 4 8 12 enero febrero marzo fila 1 1 5 9 fila 2 2 6 10 fila 3 3 7 11 fila 4 4 8 12 [,1] [,2] [,3] [1,] 1 6 11 [2,] 2 7 12 [3,] 3 8 13 [4,] 4 9 14 [5,] 5 10 15 Obtenemos la matriz traspuesta [,1] [,2] [,3] [,4] [,5] [1,] 1 2 3 4 5 [2,] 6 7 8 9 10 [3,] 11 12 13 14 15 Nos escribe el elemento sito en fila 2 columna 3 de la matriz m 82

[1] 12 Nos escriba la fila 2 [1] 2 7 12 > m[,3] Si queremos que nos escriba la columna 3 [1] 11 12 13 14 15 Podemos almacenar una fila en [1] 2 7 12 una variable > vecfila<-m[2,] > vecfila > m[2,]

El comando o funci贸n array Una quinta forma de leer una matriz es mediante el comando array > a<-1:45 > b<-array(a,dim=c(5,9)) >b

[,1] [,2] [,3] [,4] [,5] [,6] [,7] [,8] [,9] [1,] 1 6 11 16 21 26 31 36 [2,] 2 7 12 17 22 27 32 37 [3,] 3 8 13 18 23 28 33 38 [4,] 4 9 14 19 24 29 34 39 [5,] 5 10 15 20 25 30 35 40

41 42 43 44 45

Pero podria crear 3 matrices con 3 filas y 5 columnas mediante > b<-array(a,dim=c(3,5,3)) >b

,,1 [,1] [,2] [,3] [,4] [,5] [1,] 1 4 7 10 13 [2,] 2 5 8 11 14 [3,] 3 6 9 12 15 ,,2 [,1] [,2] [,3] [,4] [,5] [1,] 16 19 22 25 28 [2,] 17 20 23 26 29 [3,] 18 21 24 27 30 ,,3 [,1] [,2] [,3] [,4] [,5] [1,] 31 34 37 40 43 [2,] 32 35 38 41 44 [3,] 33 36 39 42 45

Podriamos crear una matriz con las tres filas de las matrice snum 1 num 2 y num 3 > vect<-b[1,,] > vect

[,1] [,2] [,3] [1,] 1 16 31 [2,] 4 19 34 [3,] 7 22 37 [4,] 10 25 40 [5,] 13 28 43 83

En cambio s solo quisiesemos la primera fila de la primera matriz > vect<-b[1,,1] > vect > vect<-b[2,2:4,2] > vect

obteniéndose la primera fila de la matriz 1 [1] 1 4 7 10 13 obteniéndose una subparte, de la fila 2 las columnas 3 a 4, de la matriz 2 [1] 20 23 26

Más ejemplos, creamos de nuevo una matriz m y le pedimos partes: >m

> i<-1:3 > j<-c(1,2) > m1<-m[i,j] > m1 O directamente > m1<-m[1:3,1:2] > m1 > m2<-m[1:3,-3] > m2

[,1] [,2] [,3] [1,] 1 6 11 [2,] 2 7 12 [3,] 3 8 13 [4,] 4 9 14 [5,] 5 10 15 [,1] [,2] [1,] 1 6 [2,] 2 7 [3,] 3 8 [,1] [,2] [1,] 1 6 [2,] 2 7 [3,] 3 8 Más rápido, que lea todo excepto la columa 3 (-3) [,1] [,2] [1,] 1 6 [2,] 2 7 [3,] 3 8

Algebra de matrices Podemos sumar restar multiplicary dividir elementos >m

> m[1,1]+m[1,2] > m[1,1]-m[1,2] > m[1,1]*m[1,2] > m[1,1]/m[1,2]

[,1] [,2] [,3] [1,] 1 6 11 [2,] 2 7 12 [3,] 3 8 13 [4,] 4 9 14 [5,] 5 10 15 [1] 7 [1] -5 [1] 6 [1] 0.1666667

Podemos sumar restar multiplicary dividir toda la matriz por una constante > m-5

[,1] [,2] [,3] [1,] -4 1 6 84

> m*5

> m/5

Creamos una nueva matriz m2 > m2<-matrix(a,5,3) > m2<-m2*2 > m2

Suma de matrices > m+m2

[2,] -3 2 7 [3,] -2 3 8 [4,] -1 4 9 [5,] 0 5 10 [,1] [,2] [,3] [1,] 5 30 55 [2,] 10 35 60 [3,] 15 40 65 [4,] 20 45 70 [5,] 25 50 75 [,1] [,2] [,3] [1,] 0.2 1.2 2.2 [2,] 0.4 1.4 2.4 [3,] 0.6 1.6 2.6 [4,] 0.8 1.8 2.8 [5,] 1.0 2.0 3.0 [,1] [,2] [,3] [1,] 2 12 22 [2,] 4 14 24 [3,] 6 16 26 [4,] 8 18 28 [5,] 10 20 30 [,1] [,2] [,3] [1,] 3 18 33 [2,] 6 21 36 [3,] 9 24 39 [4,] 12 27 42 [5,] 15 30 45

Multiplicaci贸n de matrices Definimos dos nuevas matrices. Cuidado con las dimensiones de las matrices para poder multiplicarlas > p1<[,1] [,2] matrix(c(2,3,4,1,4,6),ncol=2) [1,] 2 1 > p1 [2,] 3 4 [3,] 4 6 > p2<[,1] [,2] [,3] matrix(c(1,3,6,2,4,5),ncol=3,byro [1,] 1 3 6 w=T) [2,] 2 4 5 > p2 Para multiplicarlas se usa el [,1] [,2] [,3] operador %*% [1,] 4 10 17 [2,] 11 25 38 > p1%*%p2 [3,] 16 36 54

El operador %x% y el %o% 85

Otra multiplicaci贸n es %x% pero es distinta.Cada elemento de la matriz m1 multiplica a los 4 elementos de la matriz m2 obteniendose una matriz de dimensiones ampliadas Sean m1 y m2 dos matrices > m1

[,1] [,2] 2 1 3 4 [,1] [,2] [1,] 5 6 [2,] 7 8 [,1] [,2] [,3] [,4] [1,] 10 12 5 6 [2,] 14 16 7 8 [3,] 15 18 20 24 [4,] 21 24 28 32 [1,] [2,]

> m2

> m1%x%m2

Tambien hay el operador %o% que se llama multiplicacion externa, donde cada valor de la segunda matriz multiplica a la primera matriz entera > m1%o%m2

, , 1, 1 [,1] [,2] [1,] 10 5 [2,] 15 20 , , 2, 1 [,1] [,2] [1,] 14 7 [2,] 21 28 , , 1, 2 [,1] [,2] [1,] 12 6 [2,] 18 24 , , 2, 2 [,1] [,2] [1,] 16 8 [2,] 24 32

Determinantes e Inversas con R Las funciones det() y solve() calculan el determinante y la inversa respectivamente de una matriz > x<-matrix(1:9,3,3) >x

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

[,1] [,2] [,3] 1 4 7 2 5 8 3 6 9 86

> det(x) [1] 0 Al ser el deetrminante 0, la matriz Error en solve.default(x) : es singular y no hay inversa por Lapack routine dgesv: system is exactly singular: lo que se produce un error U[3,3] = 0 > solve(x) > y<-c(1,1,1,1,0,1,2,1,3) > y<-matrix(y,3,3) >y

[,1] [,2] [,3] [1,] 1 1 2 [2,] 1 0 1 [3,] 1 1 3 > det(y) [1] -1 > solve(y) [,1] [,2] [,3] [1,] 1 1 -1 [2,] 2 -1 -1 [3,] -1 0 1 > (x <- matrix(1:4, ncol = 2)) [,1] [,2] [1,] 1 3 [2,] 2 4 > unlist(determinant(x)) modulus sign 0.6931472 -1.0000000 > det(x) [1] -2 > det(print(cbind(1, 1:3, c(2,0,1)))) [,1] [,2] [,3] [1,] 1 1 2 [2,] 1 2 0 [3,] 1 3 1 [1] 3 Hay una librería de instalación denominada MASS que inclute la función inversa generalizada ginv() (Moore-Penrose)

Sistemas de ecuaciones lineales en R Supongamos el siguiente sistema lineal de ecuaciones

= 3 x + 2 y − 1z 1   3 2 −1  x   1        −2  ⇔  2 −2 4   y  = B X= A−1 B 2x − 2 y + 4z =  −2  ; A * X =⇔ −1x + 0.5 y −= 1z 0   −1 0.5 −1  z   0  Lo resolvemos en R con el comando solve

Introduciomos la matriz de Error en dim(3, 3) : 2 arguments passed to 'dim' which coeficientes A requires 1 > A<-array(c(3,2,-1,2,-2,0.5,-1,4,1),dim(3,3)) Que nos da error por lo que la escribimos bien > A<-array(c(3,2,-1,2,-2,4,-1,0.5,[,1] [,2] [,3] 1), c(3,3)) [1,] 3 2.0 -1 [2,] 2 -2.0 4 >A [3,] -1 0.5 -1 87

Introducimos la matriz términos independientes B

de 1] 1 -2 0

> B<-c(1,-2,0) >B > solve(A,B) > A %*% solve(A,B)

> solve(A)

> solve(A) %*% B

[1] 1 -2 -2 [,1] [1,] 1.000000e+00 [2,] -2.000000e+00 [3,] -2.220446e-16 [,1] [,2] [,3] [1,] 2.220446e-16 -0.500000 -2.000000 [2,] 6.666667e-01 1.333333 4.666667 [3,] 3.333333e-01 1.166667 3.333333 [,1] [1,] 1 [2,] -2 [3,] -2

Fuente http://youtu.be/jF71LzipydA Para sistemas de ecuaciones no lineales está disponible la librería BB con este tutorial http://cran.r-project.org/web/packages/BB/vignettes/BBvignetteJSS.pdf

Otras operaciones con matrices incluidas en modulo base > svd(A) > x

Descomposición en valores singulares de A

> qr(A) > eigen(A) > diag(b) > diag(A) > cov(A,B)

Descomposición QR de A Calcula los valores y vectores propios de A Crea una matriz con diagonal el vector b y el resto 0 Extrae la diagonal principal de A Calcula la covarianza de las columnas de A con las columnas de B Calcula la correlación de las columnas de A con las columnas de B Producto exterior de dos vectores o matrices Producto exterior de dos vectores o matrices Calcula por defecto el producto exterior de los dos arrays Permite usar funciones de R y propias [,1] [,2] [,3] [1,] 4 2 6 [2,] 8 4 12 [3,] 12 6 18 [4,] 16 8 24

> cor(A,B) > A %o% B > outer(A,B) > outer(A,B, FUN="*",...))

> x<-c(1,2,3,4) > y<-c(4,2,6) > x %o% y

> A<-matrix(1:4,ncol=2) > A%o%y

,,1 88

> outer(A,y,"*")

[1,] [2,]

[,1] [,2] 4 12 8 16

,,2

[1,] [2,]

[,1] [,2] 2 6 4 8

,,3 [,1] [,2] [1,] 6 18 [2,] 12 24

Funciones incluidas en R para EstadĂstica Descriptiva Con Matrices De una matriz podemos usar todas las funciones estadĂsticas implementadas en R, ya sea por filas, por columnas, por zonas o matrices completas

> a<-1:24 > x<-matrix(a,6,4) >x

Promedio de la primera fila > mean(x[1,]) Varianza de la primera columna > var(x[,1]) DeviaciĂłn estandard de la primera columna > sd(x[,1]) Suma las filas > rowSums(x) Suma las columnas > colSums(x) Promedio de filas > rowMeans(x) Promedio de columnas > colMeans(x) Podemos unir la matriz x con la fila de medias > x<-cbind(x,rowMeans(x)) >x

[,1] [,2] [,3] [,4] [1,] 1 7 13 19 [2,] 2 8 14 20 [3,] 3 9 15 21 [4,] 4 10 16 22 [5,] 5 11 17 23 [6,] 6 12 18 24 [1] 10 [1] 3.5 [1] 1.870829

[1] 40 44 48 52 56 60 [1] 21 57 93 129 [1] 10 11 12 13 14 15 [1] 3.5 9.5 15.5 21.5 [,1] [,2] [,3] [,4] [,5] [1,] 1 7 13 19 [2,] 2 8 14 20 [3,] 3 9 15 21 [4,] 4 10 16 22 [5,] 5 11 17 23 [6,] 6 12 18 24

10 11 12 13 14 15 89

La función Apply() Apply(x,MARGEN,FUNCION,ARGs) MARGEN: 1=fila 2 col c(1,2)

> m<-matrix(0:15,4,4) >m

Si queremos sumar las filas > apply(m,1,sum) Y si lo que queremos es la suma de las columnas > apply(m,2,sum) Si queremos solo sumar las columnas 2 y 3 > apply(m[,2:3],1,sum) Mínimos de cada columna > apply(m,2,min) Máximos de cada fila > apply(m,1,max) Media > apply(m,1,mean) Varianza: > apply(m,1,var) Mediana: > apply(m,1,median) Desviación estandard > apply(m,1,sd) > > > > > > > > > >

[,1] [,2] [,3] [,4] [1,] 0 4 8 12 [2,] 1 5 9 13 [3,] 2 6 10 14 [4,] 3 7 11 15 [1] 24 28 32 36 [1] 6 22 38 54

[1] 12 14 16 18

[1] 0 4 8 12 [1] 12 13 14 15 [1] 6 7 8 9 [1] 26.66667 26.66667 26.66667 26.66667 [1] 6 7 8 9 [1] 5.163978 5.163978 5.163978 5.163978

ax <- matrix(rnorm(20), ncol = 5) medias.por.fila <- apply(ax, 1, mean) por.si.na <- apply(ax, 1, mean, na.rm = TRUE) mi.f1 <- function(x) { return(2*x - 25)} mi.f1.por.fila <- apply(ax, 1, mi.f1) mas.simple <- apply(ax, 1, function(x){return(2*x -25)}) medias.por.columna <- apply(ax, 2, mean) sample.rows <- apply(ax, 1, sample) dos.cosas <- function(y){return(c(mean(y), var(y)))} apply(ax, 1, dos.cosas) > t(apply(ax, 1, dos.cosas))

Utilizar apply es generalmente mucho más eficiente que un bucle. Además de más claro, más fácil, etc.. > parameters <- cbind(mean = -5:5, sd = 2:12) > z.data <- matrix(rnorm(1000 * 11), nrow = 11) > data <- (z.data * parameters[,2]) + parameters[,1] > apply(data, 1, mean); apply(data, 1, sd) 90

Las funciones sapply(X,función) y lapply(X,función) son como apply(x,i,función) pero no hay que especificar el índice i=2; sapply intenta simplificar el resultado a un vector o a una matriz (la “s” es de “simplify”), pero lapply siempre devuelve una lista. Ambas pueden aplicarse a vectores, listas, arrays. > data(airquality) > sapply(airquality, function(x)sum(is.na(x))) La función tapply(x,y,función) calcula la función especificada sobre el objeto x según las categorías de y. > x <- c(19,14,15,17,20,23,19,19,21,18) > trat <- c(rep("A",5),rep("B",5)) > x.media <- tapply(x,trat,mean) > x.media apply, sapply, lapply y tapply son funciones muy útiles que contribuyen a hacer el código más legible, fácil de entender, y facilitan posteriores modificaciones y aplicaciones. Consejo: Cada vez que vayamos a usar un “loop” intentemos substituirlo por algún miembro de familia apply. Algunas funciones hacen un apply: > x1 <- 1:10 > m1 <- matrix(1:20, ncol = 5) > d1 <- as.data.frame(m1) > mean(x1); mean(d1); sd(x1); sd(d1); median(m1); median(d1)

Definiendo funciones para usarlas con apply() Podemos crear nuestras funciones y ejecutarlas dentro del comando aplly() Creamos una función que se denominará exp.5 y que la definimos como la suma de los valores elevados a 5 > m<-matrix(0:15,4,4) >m

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

> exp.5<-function(x){sum(x)^5} > apply (m,2,exp.5) Puedo asignar el resultado a una [1] nueva matriz > apply (m,2,exp.5) -> mexp > mexp

[,1] [,2] [,3] [,4] 0 4 8 12 1 5 9 13 2 6 10 14 3 7 11 15 7776 5153632 79235168 459165024 7776 5153632 79235168 459165024

Podemos crear la función dentro del comando apply() aunque en este caso no se usan las llaves que usamos en el modo definición > apply function(x)sum(x)^5)

(m,2, [1]

7776 5153632 79235168 459165024

Comando sample 91

Sirve para permutar todos los valores de la matriz. Cada vez que se ejecuta obtenemos una muestra (sample) distinta Muestra permutando columnas > apply(m,2,sample)

Muestra permutando filas > apply(m,1,sample)

[,1] [,2] [,3] [,4] 2 4 11 15 0 7 8 13 1 5 9 14 3 6 10 12 [,1] [,2] [,3] [,4] [1,] 12 13 6 11 [2,] 0 1 10 15 [3,] 4 9 14 3 [4,] 8 5 2 7 [1,] [2,] [3,] [4,]

Concatenando filas o columnas Vamos a a帽adirle a la matriz m dos nuevas columnas, una d emedias y otra aplicandole la funci贸n exp.5 > mmean<-apply(m,1,mean) mmean mexp > bnew<-cbind(m,mmean,mexp) [1,] 0 4 8 12 6 7776 [2,] 1 5 9 13 7 5153632 > bnew [3,] 2 6 10 14 8 79235168 [4,] 3 7 11 15 9 459165024 y ahora las nombramos > rownames(bnew)<rownames(bnew,do.NULL=F,prefi x="Paciente.") > nom.col<-c("tiempo 1","tiempo 2","tiempo 3","tiempo 4","promedio","funcion") > colnames(bnew)<-nom.col > bnew

tiempo funcion Paciente.1 Paciente.2 Paciente.3 Paciente.4

1 tiempo 2 tiempo 3 tiempo 4 promedio 0 1 2 3

4 5 6 7

8 9 10 11

12 13 14 15

6 7776 7 5153632 8 79235168 9 459165024

A la funci贸n apply() se le pueden especificar argumentos avanzados de R como que nos haga por filas un t-test

> apply(m,1,t.test)

[[1]] One Sample t-test data: newX[, i] t = 2.3238, df = 3, p-value = 0.1027 alternative hypothesis: true mean is not equal to 0 95 percent confidence interval: -2.217041 14.217041 sample estimates: mean of x 6 [[2]] 92

One Sample t-test data: newX[, i] t = 2.7111, df = 3, p-value = 0.0731 alternative hypothesis: true mean is not equal to 0 95 percent confidence interval: -1.217041 15.217041 sample estimates: mean of x 7 [[3]] One Sample t-test data: newX[, i] t = 3.0984, df = 3, p-value = 0.05336 alternative hypothesis: true mean is not equal to 0 95 percent confidence interval: -0.217041 16.217041 sample estimates: mean of x 8 [[4]] One Sample t-test data: newX[, i] t = 3.4857, df = 3, p-value = 0.03989 alternative hypothesis: true mean is not equal to 0 95 percent confidence interval: 0.782959 17.217041 sample estimates: mean of x 9 Aunque tambiĂŠn podemos parcelar la matriz

[[1]] > apply(m[3:4,],1,wilcox.test) Wilcoxon signed rank test data: newX[, i] V = 10, p-value = 0.125 alternative hypothesis: true location is not equal to 0

[[2]] Wilcoxon signed rank test data: newX[, i] V = 10, p-value = 0.125 93

alternative hypothesis: true location is not equal to 0 TambiĂŠn podemos hacer anĂĄlisis comparativos de las columnas de la matriz con otra columna dada

[[[1]] Creamos un nuevo vector y para comparar

Welch Two Sample t-test

data: x and y t = -7.7387, df = 3.296, p-value = 0.00319 alternative hypothesis: true difference in means is not Creamos una funciĂłn prueba.t equal to 0 > prueba.t<-function(x){t.test(x,y)} 95 percent confidence interval: -31.99526 -14.00474 Aplicamos prueba.t a las sample estimates: mean of x mean of y columnas 1 y 2 de la matriz m 1.5 24.5 > apply(m[,1:2],2,prueba.t) > y<-c(17,24,26,31)

Resultando

[[2]] Welch Two Sample t-test data: x and y t = -6.3928, df = 3.296, p-value = 0.005798 alternative hypothesis: true difference in means is not equal to 0 95 percent confidence interval: -27.99526 -10.00474 sample estimates: mean of x mean of y 5.5 24.5

Otras poibilidades de apply()

Creo una función ceros que transforma una matriz en 0 si el original es menor que 7 y 1 en caso contrario > ceros<function(x){if(x<7){x=0}else{x=1}}

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

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

Ahora la aplico a nuestra matriz m por filas y columnas > apply(m,c(1,2),ceros) Creo una función fun.log que si x [[1]] es distinto de cero (x! es distinto [1] 100 en R) vale log y en caso contrario suma 100 [[2]] [1] 0 > fun.log<-function(x){ [[3]] + if(x!=0){log(x)} [1] 0.6931472 + else{x+100}} Y escribimos una función lapply [[4]] [1] 1.098612 que compara m con esta funcion > lapply(m,fun.log)

[[5]] [1] 1.386294

[[6]] [1] 1.609438 ............................... Otra función más amigable es [1] 100.0000000 0.0000000 0.6931472 1.0986123 sapply que también compara 1.3862944 1.6094379 dandosnos un vector o matrioz [7] 1.7917595 1.9459101 2.0794415 2.1972246 2.3025851 2.3978953 sapply(m,fun.log) [13] 2.4849066 2.5649494 2.6390573 2.7080502 Si queremops saber si esto es un vector o una matriz > sapply(m,fun.log)->mlog > is.matrix(mlog) > is.vector(mlog)

[1] FALSE [1] TRUE

Obtenido de los videos YouTube http://youtu.be/U5td8wZXJ1Y http://youtu.be/4DE1UbQKqSQ http://youtu.be/WR8ftX-GJoE

Arrays Un array es un conjunto de datos de K dimensiones. Es una generalización de una matriz a casos n-dimensionales. Si = 2, estamos en que el array es una matriz. Todos los elementos de un array deben ser del mismo tipo, ya sea numéric, character, logic, .. En R cualquier arrayha de tener asociado un atributo llamado dimque indique los límites superiores de cada una de las dimensiones. Por definición el límite inferior es 1. > x <- 1:20 > dim(x) <- c(2, 5, 2)

Crea un vector de 20 posiciones del 1 al 20 Lo convierte en un array de 2 filas, 5 columnas y 5 de fondo. R lo representa como: ,1 [,1] [,2] [,3] [,4] [,5] [1,] 1 3 5 7 9 [2,] 2 4 6 8 10 ,,2 [,1] [,2] [,3] [,4] [,5] [1,] 11 13 15 17 19 [2,] 12 14 16 18 20

Indexando arrays Los arrays se indexan y se designa cada elemento entre corchetes igual que con vectores o matrices.

> x[1,4,2]

> x[2,4,] > x[,3,]

[1] 17 Si omitimos una dimensión, nos devuelve las componentes de la que falta [1] 8 18 Es un array de dimensiones c(2,2) y vector de datos c(x[1,3,1], x[1,3,2], x[2,3,1], x[2,3,2]) [,1] [,2] [1,] 5 15 [2,] 6 16

Un array también se indexa con array de índices que tendrá tantas columnas como dimensiones tenga el array del que se seleccionan los elementos y un indeterminado número de filas, que equivaldrá al número de elementos que queramos seleccionar. > x <- 1:20 > dim(x) <- c(4,5) >x

> i <-c(1,2,3,3,2,1) > dim(i) <-c(3,2) >i

Genera una matriz x de dimensiones c(4,5) [,1] [,2] [,3] [,4] [,5] [1,] 1 5 9 13 17 [2,] 2 6 10 14 18 [3,] 3 7 11 15 19 [4,] 4 8 12 16 20 Creamos el array de índices de dimensiones 3x2 que resulta ser la matriz de índices [,1] [,2] [1,] 1 3 [2,] 2 2 96

> x[i] > x[i] <- 0 >x

[3,] 3 1 Nos devuelve los elementos x[1,3] x[2,2] y x[3,1] [1] 9 6 3 Si ponemos estos valores a 0 resulta [,1] [,2] [,3] [,4] [,5] [1,] 1 5 0 13 17 [2,] 2 0 10 14 18 [3,] 0 7 11 15 19 [4,] 4 8 12 16 20

Listas Un lista estรก constituida por componentes que pueden ser de distinto tipo, longitud, modo, e incluso otra lista.

> list ( , , ,, ... ) > names( lista)

Crea una lista Permite asignar nombres a cada componente de una lista y preguntas port los valores de la misma

> f<-gl(2,3) ; A<matrix(1:12,ncol=4) ; x<rep(c("a","b","c"),3) ; y<-seq(10,10, by=3) ; mi.lista<list(factor=f,A=A,y,x) > mi.lista$A

Tres formas distintas d eobtener lo mismo:

> mi.lista[[2]]

[,1] [,2] [,3] [,4] [1,] 1 4 7 10 [2,] 2 5 8 11 [3,] 3 6 9 12 [1] -10 -7 -4 -1 2 5 8

> mi.lista[["A"]] > mi.lista[[3]]

> mi.lista[3] > mi.lista[[2]][1,] > names(mi.lista) > mode(mi.lista) > length(mi.lista)

[[1]] [1] -10 -7 -4 -1 2 5 8 [1] 1 4 7 10 [1] "factor" "A" "" "" [1] "list" [1] 4

Data.frames Los marcos de datos, o mejor en inglés dataframes, son estructuras matriciales con contenidos mixtos, es decir contienen diferentes tipos de datos (vectores, factores, números, matrices u otros data.frame) Son las estructuras idóneas para recoger tablas de datos por la heterogeneidad que éstos llegan a contener (numéricos, alfanuméricos, factores, lógicos, arrays ....) Normalmente las filas corresponden a una observación y cada columna a una de las variables. Ejemplo

> rtead.csv(file="filename") > dataframe(v1, v2, ....,vk) > is.data.frame(x) > as.data.frame(x) > expand.grid > names () > class() > unclass() > sapply() > lapply() > dim() > data[i,j] > data[i,] > data[,j] > data&nombre_col > x<-c(1,2,3,4,5) > z<-c("A","B","A","C","C") >datos<- dataframe (x, z) > datos

> datos<- dataframe (x,as.factor(z)) > datos

> dim(datos)

> rownames(datos)

Lee un archivo en disco Crea un dataframe Nos dice si la variable x en cuestión es o no es un dataframe Convierte un objeto en un dataframe Crea una hoja de datos combinando varios factores Nombres de los compopnentes de una lista Nos dice la clase del objeto Elimina el atributo de clase Aplica una función a cada componente de una lista Nos indica las dimensiones en filas y columnas del dataframe Extrae el elemento de la fila i columna j del dataframe Extrae la fila i-ésima Extrae la columna j-ésima Extrae la columna de nombre nombre_col Introducimos un vector x Introduciomos un vector z tipo character Creo un dataframe llamado datos compuesto por dos vectores el x (numerico) y el z (character) xz 11A 22B 33A 44C 55C Creo un dataframe llamado datos compuesto por dos vectores el x y el z previo traspaso a tipo factor x as.factor.z. 11 A 22 B 33 A 44 C 55 C Nos dice cuantas filas y columnas tiene el dataframe datos [1] 5 2 Las filas no tienen nombre y aparecerá 99

> rownames(datos)<c("primero","segundo","3º","4º","5 º") > datos

> colnames(datos)<c("var1","var2") > datos

> class(datos) > class(datos[,1]) > class(datos[,2]) > datos[,2] > datos$var2

[1] "1" "2" "3" "4" "5" Una vez nombrados queda x as.factor.z. primero 1 A segundo 2 B 3º 3 A 4º 4 C 5º 5 C Nombra las columnas var1 var2 primero 1 A segundo 2 B 3º 3 A 4º 4 C 5º 5 C [1] "data.frame" La primera columna es numerica [1] "integer" La segunda columna es tipo factor [1] "factor" [1] A B A C C Levels: A B C En lugar de corchetes pouedo usar el nombre de la columna [1] A B A C C Levels: A B C

Reordenación de un data.frame Podemos ordenar un data.frame por alguna de sus filas o columnas

x <- c(3,2,1,5,4) y <- c("D","B","A","E","C") mydata <- data.frame(x,y) mydata

> mydata <- mydata[order(mydata$x),] > mydata

> mydata <- mydata[order(mydata$y),] > mydata

Introducimos un vector x y uno y, y construimos con ellos un data.frame xy 11D 22B 33A 44E 55C Ordenamos por la columna x xy 31A 22B 13D 54C 45E Ordenamos por la columna y xy 31A 22B 100

> rownames(mydata) <- 1:5 > mydata

> mydata <- mydata[order(-mydata$x),] > mydata

54C 13D 45E Renombro las filas acordes a la nueva ordenaci贸n xy 11A 22B 34C 43D 55E Tambien se puede reordenar de forma descendente xy 55E 34C 43D 22B 11A

101

OBJETOS EN R R es mucho más que una calculadora científica en la que aplicar unos comandos o instrucciones. R es un lenguaje Orientado a Objetos. Bajo este término se esconde la simplicidad y flexibilidad de R. Mientras que programas más clásicos muestran directamente los resultados de un análisis, R almacena los resultados en objetos, para ser observados o analizados posteriormente, produciendo unas salidas mínimas. Esto puede ser un poco extraño para el usuario, pero esta característica suele ser muy útil. De hecho, el usuario puede extraer sólo aquella parte de los resultados que le interesa. Sin embargo, en otros programas como SAS o SPSS se obtendría de modo inmediato una salida copiosa para cualquier análisis. Casi todo en R es un objeto, incluyendo •

comandos,

•

funciones y

•

estructuras de datos. o

variables, arrays y matrices

Factors,

listas

Data Frames

Cualquier objeto en R tiene las propiedades •

mode, que nos dice el tipod e datos que conforman el objeto (numerico, complex, logical ...) y

•

length o número de elementos que lo componen

Cada instrucción que ejecutamos nos proporciona nuevos objetos. Los vectores son el tipo básico de objeto en R, pero existen más tipos (los veremos de modo formal en la siguiente sesión). Las matrices o, más generalmente, variables indexadas (Arrays) son generalizaciones multidimensionales de los vectores. De hecho, son vectores indexados por dos o más índices. Los factores sirven para representar datos categóricos. Las listas son una forma generalizada de vector en las cuales los elementos no tienen por qué ser del mismo tipo y a menudo son a su vez vectores o listas. Las listas permiten devolver los resultados de los cálculos estadísticos de un modo conveniente.

102

Las hojas de datos (data frames) son estructuras similares a una matriz, en que cada columna puede ser de un tipo distinto a las otras. Las funciones son también objetos de R que pueden almacenarse en el espacio de trabajo, lo que permite extender las capacidades de R fácilmente. Consecuente con sus orígenes en UNIX, R distingue entre mayúsculas y minúsculas, de tal modo que A y a son símbolos distintos y se referirán, por tanto, a objetos distintos. Los nombres de los objetos pueden contener sólo letras mayúsculas o minúsculas (son distintas), junto con números y puntos (NO blancos, NO __ , NO%, NO $, etc.). Los corchetes o dobles corchetes se utilizan para seleccionar partes de un objeto así como el dólar. Durante una sesión de trabajo con R los objetos que se crean se van almacenando por su nombre.

Tipos de objetos ¿Qué tipos de objetos hay en R? Ya dijimos que todo en R son objetos.

Hay una función, la class( ), que nos cataloga el tipo de objeto que tenemos

> x<-1 > class(x) [1] "numeric" > Is.classname() > is.numeric() > is.character() ....

> as.classname() > as.numeric() > as.character() ....

Asigna al objeto x el valor 1 Función que nos dice de que clase es un objeto R dado En este caso x es un objeto numérico Nos permite determinar si un objeto dado es de un tipo dado. ejemplo > class(x) [1] "numeric" > Is.numeric(x) [1] TRUE > Is.character(x) [1] FALSE Coinvierte una clase en otra >x [1] 1 > as.character(x) [1] "1" > y<-as.character(x) > class(y) [1] "character" > Is.character(y) [1] TRUE

103

LIBRERÍAS DE R (packages) R contiene una amplia variedad de funciones, procedimientos que implementan un algoritmo que recibe unos datos de entrada (argumentos), realiza unas transformaciones y devuelve un dato de salida. Para utilizar una función en R se utiliza la siguiente síntaxis: nombre.funcion(argumento.1, argumento.2, ..., argumento.n) Por ejemplo, R tiene implementa funciones numéricas básicas como: > x <- abs(-2)

Función valor absoluto incluída modulo base

> y <- log10(10)

Función logaritmo modulo base

decimal,

incluída

> z <- log2(64)

Función logaritmo modulo base

base

incluída

> suma.cuadrados <- function(dato1,dato2) { cuadrado1 <- dato1 * dato1 cuadrado2 <- dato2 * dato2 resultado <- cuadrado1 + cuadrado2 return (resultado) }

Funcion propia definida por mi

R consta de un sistema base (donde están incluidas una enorme cantidad de técnicas estadísticas y numéricas) y de paquetes (packages) adicionales que extienden su funcionalidad. El hecho de distinguir entre ambos conceptos es fundamentalmente una cuestión histórica. Junto con R se incluyen ocho paquetes (llamadas paquetes estándar) pero otros muchos están disponibles a través de Internet en CRAN: http://cran.es.r-project.org/ Podrás observar que existen paquetes de Redes Neuronales disponibles para r como AMORE, brnn, condmixt, elmNN, GMDH, grnn, monnlp, neural, neural net, NeuralNetTools, nnet, pnn, qrnn, RSNNS, TeachNet y también paquetes de Data Mining DMwR, ElemStatLearn, FactoMineR, freestats, rattle, rminer, RODM, TDMR, vdmR Tarea Conectarse a CRAN y observar los paquetes disponibles (a principios de febrero de 2015 ya hay 6400). Tarea: Instalar el paquete foreign. 104

Usando funciones incorporadas en el módulo base Hay funciones accesibles de forma inmediata, incorporadas por defecto con el paquete básico, lo que se llama el núcleo o el core de R, ejemplo mean(), var(), sd(), cor(x,y). Estas funciones se usan directamente.

Incorporando las librerías instaladas en la sesión de R. Hay funciones que aunque vienen con el paquete base, hay que invocar a esos paquetes para que dichas funciones sean accesibles, por ejemplo mvrnorm() que es una funcion que genera números aleatorios dentro de una distribución normal bivariante. Esta funcion no está en el core, hay que instalarla previamente. Existen dos maneras de hacerlo: •

desde el menú Paquetes > Cargar paquete... seleccionamos la librería que queramos,

•

bien desde la línea de comandos utilizando la función library() o la require()

> ?mvrnorm

Nos dice que no está

> ??mvrnorm

Aunque no está nos dice en que paquetes se encuentra. Observamos que se encuentra en un paquete llamado MASS

> installed.packages()

obtenemos un listado de todos los paquetes del repositorio.

> require(MASS)

Carga la libreria MASS

> librery(MASS)

Carga la libreria MASS, es equivalente a require

> libarry(help="foreign")

Abre una ventana de ayuda sobre la librería foreign

> ?mvrnorm

Ahora nos dice que sí que está disponible

> library(help="foreign")

Abre una ventana de ayuda sobre la librería foreign

> search( ) > detach(mylibrary)

Descarga la libreria mylibrary

105

Incorporando librerías del repositorio Supongamos ahora un tercer caso que es el de que necesitemos instalar una librería más específica que no viene ni en el módulo base ni en el paquete estándar de librerías instaladas, aunque sabemos que existe en un paquete del repositorio de R. Ejemplo, supongamos que queremos hacer un análisis de componentes principales de dos vectores x e y. La función es princom() pero hay otra mejor es la función PCA() que no está ni en CORE ni en ningún paquete preinstalado. Para saberlo hay que documentarse, pero yo ya sé que es la librería que la contiene se llama FactoMIneR > x<-1:5

Definimos dos vectores x e y

> y<-c(2,4,5,6,7) >x [1] 1 2 3 4 5 >y [1] 2 4 5 6 7 > install.packages("FistoMineR")

Este comando instala FactoMineR y todos los dependes

> installed.packages()

Nos da ahora un listado de todo lo que hemos instalado y ya aparece FactoMineR

> ?PCA

No la conoce porque la instalación del paquete no implica que los paquetes ya puedan ser utilizados. Es necesario cargar las librerías antes de empezar a usarlas.

> librery(FactoMineR)

Carga la librería FactoMineR y todos los paquetes que dependan de él

> ?PCA

Ahora si que ya nos informa de como funciona la función PCA

106

GRÁFICOS EN R. R tiene una gran potencialidad para generar gráficos. En este tutorial introduciremos las principales funciones para realizar gráficos, plot, lines, points, hist, etc. según las necesitemos. > demo("graphics")

Ejecuta un damo incluida en R para que puedas comprobar su potencial gráfico.

> win.graph() > x11() > windows()

Cualquiera de ellos inicializa una ventana para gráficos (graphic device) y la deja como disposito activo, al cual se enviarán todos los dibujos.

> dev.set(2)

Para activar uno u otro de los dispositivos gráficos disponibles

> dev.off(3)

Elimina una ventana gráfica previamente inicializada

Las prinicipales funciones para dibujar son

barplot

Diagrama de barras

boxplot

Diagrama de caja

contour

Gráfico de contorno

hist

Histograma

pairs

Pares de gráficos de dispersión por variables

persp

gráficos 3D

Plot

Rutina de dibujo general

Locator Text identify Vamos a introducir los gráficos con un ejemplo sencillo

El plot El comando plot(x, y), donde x e y son vectores de n componentes, representa un gráfico de dispersión con los puntos de coordenadas (xi, yi). El propio comando elije por defecto los ejes, escalas, densidad de líneas que pueden ser modificadas por el usuario

> x<-1:5 > y<-c(3,1,2,4,9) > plot(x,y) > hist(y)

Asigna al objeto x el valor 1 Dibuja estos puntos en el plano Dibuja en histograma de los valores y 107

> pie(y) Dibuja un diagrama de sectores > plot(x,y,type="b") Unir los puntos por líneas > plot(x, y, type="b", Dibuja en grafico con xlab="Tiempo", ylab="Velocidad", • type b linea entre puntos main="V/T", sub="En condiciones • xlab etiqueta eje X ideales", xlim=c(0,10), • ylab etiqueta eje Y ylim=c(0,6), col="red") • main titulo principal • sub titulo secundario • xlim valores eje X • ylim valores eje Y • col color linea > y2<-c(2,4,3,1,0) Creamos un nuevo vector y2 > points(x,y2,type="b",col="blue") > abline(h=3,col="green") Dibuja linea horizontal y vertical > abline(v=3,col="yellow") > legend("topleft", Dibuja un cuadrado en la parte superior izquierda para legend=c("A","B"), describir que linea es cada una col=c("red","blue"), lty=1) Obteniéndose

Vamos ahora a hacer ejemplos de variaciones del comando plot

> x<- runif(50,0,4) > y<- runif(50,0,4)

Crea dos vectores x e y de 50 componentes aleatorias siguiendo una distribución uniforme entre 0 y 4

108

> plot(x,y)

> plot(x, y, main = "Titulo principal", sub = "subt覺tulo", xlab = "eje x", ylab = "eje y",xlim = c(5,5),ylim = c (-5,5))

> z <- cbind(x,y) > plot(z) > plot(y ~ x) > plot(log(y + 1) ~ x) # transformacion de y > plot(x, y, type = "p") > plot(x, y, type = "l")

Crea una matriz z de columnas x e y Dibuja lo mismo que plot(x,y)

Dibuja solo puntos Dibula solo l穩neas

109

> plot(x, y, type = "b")

Dibula puntos y lĂneas

> plot(c(1,5), c(1,5))

Dibuja dos puntos (1,1) y (5,5)

110

> legend(1, 4, c("uno", "dos", "tres"), lty = 1:3, col = c("red", "blue", "green"), pch = 15:17, cex = 2)

x <- c(1:5); y <- x # create some data par(pch=22, col="red") # plotting symbol and color par(mfrow=c(2,4)) # all plots on one page opts = c("p","l","o","b","c","s","S","h") for(i in 1:length(opts)){ heading = paste("type=",opts[i]) plot(x, y, type="n", main=heading) lines(x, y, type=opts[i]) }

x <- c(1:5); y <- x # create some data par(pch=22, col="blue") # plotting symbol and color par(mfrow=c(2,4)) # all plots on one page opts = c("p","l","o","b","c","s","S","h") for(i in 1:length(opts)) { heading = paste("type=",opts[i]) plot(x, y, main=heading) lines(x, y, type=opts[i]) }

111

Una pรกgina extraordinaria para ampliar conocimientos sobre grรกficos en R, que contiene gran cantidad de ejemplos es http://www.statmethods.net/ Y concretamente http://www.statmethods.net/graphs/scatterplot.html

112

El Boxplot Vamos a ver como hacer un grรกfico copn el comando boxplot del paquete bรกsico de R > normal<- Creamos un vector llamado normal con 200 datos rnorm(200,mean=100,sd=30) aleatorios de una N(100,30) > Este comando divide la pantalla grafica en dos partes par(mfrow=c(2,1),mar=c(3,5,3,5)) > hist(normal,freq=F,breaks=50,col ="51", main="DISTRIBUCION NORMAL", xlim=c(0,200))

> boxplot(normal,ylim=c(0,200),col= c("51"),horizontal=T)

> par(mfrow=c(1,1),mar=c(3,3,3,3)) > boxplot(normal) BASICO

Cambiamos la configuraciรณn de mi pantalla grafica

#boxplot

113

> boxplot(normal, col="lightcoral", main="Dist. Normal RANGE 1.5", ylab="DENSIDAD", ylim=c(0,200), horizontal=F, range=1.5)

> boxplot(normal, col="lightcoral", Mopdificamos solo los whisker main="Dist. Normal RANGE 1.5", ylab="DENSIDAD", ylim=c(0,200), horizontal=F, range=0.5)

Dibujar rectas Podemos añadir muchos elementos a un gráfico, además de leyendas y líneas rectas. > x <- rnorm(50) > y <- rnorm(50) > plot(x, y) > lines(lowess(x, y), lty = 2) > plot(x, y) > abline(lm(y ~ x), lty = 3) 114

Podemos añadir otros elementos con “panel functions” en otras funciones (como pairs, lattice, etc).

Dibujar funciones en R A un gráfico se le pueden añadir elementos más allá de los elementales ya descritos como •

escribir leyendas;

•

dibujar lineas rectas,

•

añadirle más elementos (pairs, lattice, etc.) con "panel functions"

•

aparte podemos dibujar funciones que definamos nosotros o que ya estén definidas en R;

•

también podemos modificar márgenes exteriores de figuras y entre figuras (véase ?par y búsquense oma, omi, mar, mai) ;

•

dibujar gráficos 3D con persp, image, contour;

•

gráficos tridimensionales dinámicos con XGobi y GGobi;

•

histogramascon hist;

•

gráficos de barras con barplot;

•

gráficos de comparación de cuantiles, para comparar la distribución de dos variables, o la disribución de unos datos frente a un estándar (como la distribución normal): qqplot, qqnorm y, en paquete car, qq.plot;

•

Podemos escribir expresiones con notación matemática (plotmath) y texto complejo.

Para ampliar Consultar ejemplos en An introduction to R, secc. 12.5.3 y 12.5.4. http://cran.r-project.org/src/contrib/Descriptions/xgobi.html, http://www.ggobi.org, http://www.mcs.vuw.ac.nz/~ray/R-stuff/windows/gguide.pdf.

> x <- rnorm(50) > y <- rnorm(50) > plot(x, y) > lines(lowess(x, y), lty = 2) > abline(lm(y ~ x), lty = 3)

Crea dos vectores x e y de 50 componentes aleatorias siguiendo una N(0,1) Dibuja los puntos (x,y) en un plano Dibuja una linea de regresion suavizada (funcion lowess) del tipo 2 (rayas discontinuas) Dibuja una linea recta de regresion (abline) tipo 3 (puntos más pequeños)

115

> fun=function(x){x^2-2*x} > plot(fun)

Definimos una funcion que se llama fun La dibujamos

> plot(fun,-3,3)

116

> curve(fun,-6,6)

Múltiples gráficos por ventana Empezamos con par(mfrow=c(filas,columnas)) antes del comando plot. > par(mfrow = c(2, 2)) > plot(rnorm(10)) > plot(runif(5), rnorm(5)) > plot(runif(10)) > plot(rnorm(10), rnorm(10)) Podemos mostrar muchos gráficos en el mismo dispositivo gráfico. La función más flexible y sofisticada es split.screen, bien explicada en R para principiantes, secc. 4.1.2 (p. 30).

Datos multivariantes Diagrama de dispersión múltiple. > X <- matrix(rnorm(1000), ncol = 5) > colnames(X) <- c("a", "id", "edad", "loc", + "weight") > pairs(X) 117

Gráficos condicionados (revelan interacciones). > Y <- as.data.frame(X) > Y$sexo <- as.factor(c(rep("Macho", 80), + rep("Hembra", 120))) > coplot(weight ~ edad | sexo, data = Y) > coplot(weight ~ edad | loc, data = Y) > coplot(weight ~ edad | loc * sexo, data = Y)

La librería lattice permite lo mismo, y mucho más, que coplot.

Un poco de ruido Los datos cuantitativos discretos pueden ser difíciles de ver bien. Podemos añadir un poco de ruido con el comando jitter. > dc1 <- sample(1:5, 500, replace = TRUE) > dc2 <- dc1 + sample(-2:2, 500, replace = TRUE, + prob = c(1, 2, 3, 2, 1)/9) > plot(dc1, dc2) > plot(jitter(dc1), jitter(dc2))

Más gráficos Podemos modificar márgenes exteriores de figuras y entre figuras (véase ?par y búsquense oma, omi, mar, mai; ejemplos en An introduction to R, secc. 12.5.3 y 12.5.4. También gráficos 3D: persp, image, contour; histogramas: hist; gráficos de barras: barplot; gráficos de comparación de cuantiles, usados para comparar la distribución de dos variables, o la disribución de unos datos frente a un estándar (ej., distribución normal): qqplot, qqnorm y, en paquete car, qq.plot. Notación matemática (plotmath) y expresiones de texto arbitrariamente complejas. Gráficos tridimensionales dinámicos con XGobi y GGobi. Ver: http://cran.r-project.org/src/contrib/Descriptions/xgobi.html, http://www.ggobi.org, 118

http://www.mcs.vuw.ac.nz/~ray/R-stuff/windows/gguide.pdf.

Ahora vamos a usar una función plotFun que dibuja funciones pero no está en el paquete básico

> plotFun(3*X-2 ~ x, x.lim=range(0,10))

Como la función no está en el paquete básico nos dice Error: no se pudo encontrar la función "plotFun"

> Para continuar Ver video youtube Creating and Graphing Mathematical functions in R C. Higdon-Topaz

Guardar gráficos En Windows, podemos usar los menús y guardar con distintos formatos. También podemos especificar donde queremos guardar el gráfico. > pdf(file = "f1.pdf", width = 8, height = 10)

Guarda en formato pdf

> plot(rnorm(10)) > dev.off() > plot(runif(50)) > dev.copy2eps()

También podemos copiar una figura a un fichero

119

PROGRAMACIÓN EN R. Naturalmente en R también podemos programar, ya sea para construir funciones pequeñas que te faciliten la labor, ya sea porque no las encuentras en ninguna librería o porque las has definido tu. O ya sea también para escribir procedimientos más grandes tipo subrutinas. Pero, además: •

R es un verdadero “object-oriented language”.

•

R puede llamar código compilado en C/C++ y FORTRAN. Ver .C, .Call, .Fortran.

•

“Lexical scoping” es importante en programación avanzada.

•

Dispone de “computing on the language” (ej.,do.call, eval, etc.)

Los programas en R se escriben en un archivo que se guarda en formato ASCII con extensión ‘.R’. Se usa habitualmente cuando lo vamos a requerir en repetidas ocasiones. Usaremos el caracter ‘#’ para agregar comentarios al programa y que serán ignorados por R durante la ejecución.

Funciones definidas por el usuario De forma general, una función se define con una asignación de la forma nombre.funcion <- function(arg1,arg2,...){expresión} La expresión es una fórmula o grupo de fórmulas que utilizan los argumentos para calcular su valor. El valor de dicha expresión es el valor que proporciona R en su salida y ´este puede ser un simple número, un vector, una gráfica, una lista o un mensaje. Las variables definidas dentro del cuerpo de una función son locales, y desaparecen al terminar la ejecución de la función. En mucha socasiones, una función puede tener varios argumentos, y podemos optar a omitir algunos de ellos, asumiendo que la función tomará por defecto unos valores internamente especificados. Ejemplo 1: Tirar un dado y contar Podemos escribir también nuestras propias funciones. En este apartado vamos a ver un ejemplo muy simple. Se trata de escribir una función que simule los resultados de n tiradas de un dado. Por defecto n=50. El resultado es un vector que contiene las frecuencias de cada posible resultado. Abrimos el editor (Archivo, Abrir script) y escribimos: Dado <- function(n = 50) { lanzamientos<-sample(1:6,n,rep=TRUE) frecuencias<-table(lanzamientos) return(frecuencias) }

# Genera n lanzamientos de un dado y devuelve la tabla de frecuencias # Selecciona con reemplazamiento n números en 1,2,...,6 # Obtiene la tabla de frecuencias 120

Una vez guardado el fichero que contiene la función podemos usar source(nombre del fichero) para cargar la función en el área de trabajo y poder usarla o, alternativamente, copiar y pegar el código anterior en la consola. Una vez hecho esto, ya podemos usar la función. Dado(1000)

Dado()

## lanzamientos ## 1 2 3 4 5 6 ## 157 176 170 161 157 179 Si no especificamos ningún argumento se usará el valor establecido por defecto n=50 ## lanzamientos ## 1 2 3 4 5 6 ## 9 3 12 10 7 9

Ejemplo 2: Suma de los términos de una progresión aritmética

sumaPA <- function(a1,d,n) { an <- a1+(n-1)*d; ((a1+an)*n)/2 }

sumaPA será a partir de esta definición una nueva función con tres argumentos • a1, que el el primer término de la progresión • d, que es la razón o diferencia, • n, que es el número de términos.

> sumaPA(2, 4, 100)

Nos responderá [1] 20000

an = a1 + (n − 1) ⋅ d sumaPA =

(a1 + an ) ⋅ n 2

Ejemplo 3: Teorema de Pitágoras

hip <- function(cat1,cat2) {temp = (cat1^2 + cat2^2) sqrt(temp) }

Otra función básica con dos argumentos que son los catetos y la función calcula la hipotenusa

> hyp(4,3)

[1] 5

> hyp(4,5)

[1] 6.403124

Argumentos > una.f <- function(a,b,c = 4,d = FALSE){x1<-a*z ...} > una.f(4, 5) > una.f(b = 5, a = 4)

Una función con cuatro argumentos Los argumentos c y d tienen valores por defecto. Podemos especificarlos nosotros o no (i.e., usar los valores por defecto) Los argumentos a y b tienen que darse en el orden debido o, si los nombramos, podemos darlos en cualquier orden 121

> una.f(c = 25, 4, 5) # error > args(nombre.funcion) > f3 <- function(x, y, label = "la x", ...){ + plot(x, y, xlab = label, ...)} > f3(1:5, 1:5) > f3(1:5, 1:5, col = "red") > f <- function(x,y) { cos(y)/(x^2-3) } > z <- outer(x,y,f)

Pero los argumentos con nombre siempre se tienen que dar después de los posicionales Nos muestra los argumentos de cualquier función. “...” permite pasar argumentos a otra función

Para realizar funciones de dos variables se puede utilizar el comando outer

Ejecución de una función definida por el usuario Para que una función pueda ser ejecutada es necesirio primeramente cargarla en memoria. Para ello: •

Escribimos las líneas de función directamnete en la consola o bien las copiamos y pegamos de otra fuente

•

Si la función estuviese guardada en nuestro disco en código ASCII la podríamos cargar con el comendo source(function.name)

•

Si deseamos cargarla siempre que iniciemos R deberá estar incluida en un fichero llamado workspace.RData y esto hará que se cargue automáticamente cada vez que iniciemos R

•

Creando un paquete o librería específico del usuario

Un avez cargada solo hay que escribir su nombre seguido, entre paréntesis, de todos sus argumentos

Scope En la función una.f “z” es una “free variable”: ¿cómo se especifica su valor? Lexical scoping. • Ver documento "Frames,environments and scope" in R and S-PLUS de J Fox en http://cran.r-project.org/doc/contrib/Fox-Companion/appendix.html • y sección 10.7 en An introduction to R. • También ver demo(scoping). Un ejemplo: cubo <- function(n) { sq <- function() n*n # aquí n no es un argumento n*sq() } En esto R (lexical scope) y S-PLUS (static scope) son distintos.

Funciones que devuelvan un vector o más de una variables 122

Supongamos que queremos una función que de un vetor nos extraiga la media, la varianza y la desviación típica y la suma de las componentes de ese vector. MyStat = function(x) { temp=c(mean(x),var(x),sd(x),sum(x)) return(temp) }

Creo una función MyStat que parámetros mde un vector Hay que usar el comando return

devuelve

varios

> x<-c(1,2,3,4,5) > MyStat(x) [1] 3.000000 2.500000 1.581139 15.000000 Otro ejemplo, la función which.max(x) nos devuelve el máximo del vector x. Vamos a crear una función que nos diga las posiciones de todos los máximos de un vector x

MyX <- c(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, Entramos este vector MyX de 31 componentes 12, 13,14, 15, 16, 17, 18, 19, 20, 20, 20, 19, 18, 17, 16, 15, 14, 13, 20, 20) My.Which.Max <- function(x) { return(which(x == max(x))) Que devuelva Cuales componentes de x coinciden con } max(x) [1] 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 MyX 19 20 20 20 19 18 17 [26] 16 15 14 13 20 20 My.Which.Max(MyX)

[1] 20 21 22 30 31

Valores por defecto R usa también valores por defecto (default) tales que, si no se especifican se toma el valor predeterminado en su definición. Para ver un ejemplo vamos a calcular de un vector sus cinco mayores términos o bien los 5 menores.

Max5 <- function(x, mayor = TRUE, n = 5) { if (mayor) temp = sort(x,T) else temp <- sort(x,FALSE) return (temp[1:n]) } test <- rnorm(20)

Temp almacena el vector x ordenado mayor a menor Y si mayor = FALSE lo extrae de menor a mayor Devuelve las primeras n componentes de x Crea un vector de 20 componentes distribuido N(0,1)

print(Max5(test),digits=2) print(Max5(test,n=7),digits=2) print(Max5(test, mayor=F) ,digits=2) print(Max5(test,F) ,digits=2)

[1] 2.07 1.09 1.03 0.92 0.89 Al decir n = 7 saca los 7 primeros [1] 2.07 1.09 1.03 0.92 0.89 0.78 0.56 Al decir mayor = F saca los 5 ultimos [1] -1.68 -1.32 -1.08 -1.02 -0.89 Lo mismo que antes [1] -1.68 -1.32 -1.08 -1.02 -0.89

print(Max5(test,F,5) ,digits=2) [1] -1.68 -1.32 -1.08 -1.02 -0.89

123

Anidamiento de funciones y argumentos Las variables internas empleadas en el calculo de las funciones se pierden al terminar de usar la función, no se pasan al flujo priniocpal del programa. Sin embargo, los argumentos si pueden irse pasando. Por ejemplo velocidad <- function(e,t) { e/t }

Creo la función velocidad con argumentos e (espacio) y t (tiempo)

> velocidad (4,2) aceleracion <- function (e,t) { velocidad(e,t)/t }

[1] 2

> aceleracion (16,2) > e <- 16 ; t <- 2

[1] 4 Los argumentos se traspasan de función a función

> aceleracion (e,t)

[1] 4

Creo la función aceleración que usa como argumentos los mismos que la función velocidad e (espacio) y t (tiempo), Y además usa internamente esta función velocidad antes definida para su cálculo

124

Control de ejecución Las principales instrucciones de R son •

if(cond) expr

•

if(cond) cons.expr else alt.expr

•

for(var in seq) expr

•

while(cond) expr

•

repeat expr

•

break

•

La expresión expr (también alt.expr) puede ser una expresión simple o una de las llamadas expresiones compuestas, normalmente del tipo {expr1; expr2}. Y no te olvides de las llaves que suele ser uno de los errores de sintaxis más frecuentes al escribir código en R.

Sentencia condicional if / else y sentencia ifelse if (cond.logica) instrucción else instrucción.alternativa > + + + + + + > >

f4 <- function(x) { if(x > 5) print("x > 5") else { y <- runif(1) print(paste("y is ", y)) } } f4(4) f4(7)

Defino función f4 Sentencia if Sentencia else Asigno a y un valor aleatorio siguiendo la distribución uniforme Al ejecutarla obtendríamos [1] "y is 0.457077476661652" [1] "x > 5"

Las sentencias if se pueden anidar dando lugar a estructuras del tipo if (caso1) {instrucción1} elseif if(caso2) {instrucción2} elseif if(caso3) {instrucción3} else instrucción4 Alternativamente, hay una versión vectorizada de la secuencia if: ifelse (cond, Instrucción si TRUE , instrucción si FALSE) > odd.even <- function(x) { + ifelse(x %% 2 == 1, "Odd", "Even") +} 125

> mtf <- matrix(c(TRUE, FALSE, TRUE, TRUE), + nrow = 2) >mtf

> ifelse(mtf, 0, 1)

Introducimosla matriz mtf La visualizamos [,1] [,2] [1,] TRUE TRUE [2,] FALSE TRUE La convierte TRUE = 0 False = 1 [,1] [,2] [1,] 0 0 [2,] 1 0

Ejercicio Crear dos listas; una para guardar los números pares de 1 a 10, y otra para los impares > > > > + +

n<-10 pares<-c() impares<-c() for(i in 1:n) { if(i%%2==0) pares<-c(pares,i) else impares<-c(impares,i)}

# # # # # #

Se inicializa n con valor 10 Se crea un vector vacío llamado pares Se crea un vector vacío llamado impares Se van a procesar los números de 1 a n Si al dividir por 2 es 0 va al vector pares Si al dividir por 2 no es 0 va al vector impares

> pares [1] 2 4 6 8 10 > impares [1] 1 3 5 7 9

126

Bucles, sentencias for( ) y while( ) for (variable.loop in valores) { instrucciones} while (variable.loop in valores) { instrucciones} Similar a todos los lenguajes de programaci贸n , en R disponemos de bucles for y while , con similar comportamiento y una sintaxis siempre parecida > for(i in 1:10) cat("el valor de i es", i, "\n")

Obetenemos : el valor de i es 1 el valor de i es 2 el valor de i es 3 el valor de i es 4 el valor de i es 5 el valor de i es 6 el valor de i es 7 el valor de i es 8 el valor de i es 9 el valor de i es 10

> + + + +

Escribe los cuadradops de los diez primeros naturales: [1] 1 [1] 4 [1] 9 [1] 16 [1] 25 [1] 36 [1] 49 [1] 64 [1] 81 [1] 100

for(i in 1:10) { j <- i * i print(j) }

O equivalentemente > for(i in 1:10) {print(i^2)}

> > > + + + + > > > >

continue.loop <- TRUE x <- 0 while(continue.loop) { x <- x + 1 print(x) if( x > 10) continue.loop <- FALSE } break next repeat instrucci贸n switch(expresion ....)

para salir de un bucle (loop) Termina la iteraci贸n actual y salta a la siguiente Repite hasta que aparezca un break Para seleccionar uno entre varios argumentos

Vamos a hacer otro bucle sencillo que dibuje lineas de colores distintos

127

> x<-seq(-10,10) >x [1] -10 -9 -8 -7 -6 -5 -4 -3 -2 -1 1 2 3 4 [16] 5 6 7 8 9 10 > plot(x,x,xlim=c(0,10),ylim=c(0,10)) > for(i in 1:10) + abline(h=i,col=i) > for(i in 1:10) + abline(v=i,col=i)

El bucle while es similar while ( condicion logica) { instrucciones} > cuadrado<-0 > while(cuadrado<=1000) { + n<-n+1 + cuadrado<-n^2 +} > cuadrado [1] 1024 >n [1] 32 > 32^2 [1] 1024

Queremos calcular qué número es el mayor cuyo cuadrado no excede de 1000 Este bucle con while nos saca n=32 porque en ese momento salió del bucle al no cumplir la condición cuadrado<-n^2 por lo que el número pedido debería añadirse al programa como n<-n-1

128

Depuración Cuando R produce un error tenemos herramientas para facilitar su depuración Cuando se producen errores o la función da resultados incorrectos o “warnings” indebidos podemos seguir la ejecución de la función.

> traceback() > browser()

> debug(my.buggy.function) > .... > undebug(my.buggy.function)

En caso de error, nos informa de la secuencia de llamadas antes del “crash” de nuestra función. Interrumpe la ejecución a partir de ese punto y permite seguir la ejecución o examinar el entorno; con “n” paso a paso, si otra tecla sigue la ejecución normal. “Q” para salir. es como poner un broswer al principio de la función y ésta se ejecuta paso a paso. Ejemplo > my.f2 <- function(x, y) { + z <- rnorm(10) + y2 <- z * y + y3 <- z * y * x + return(y3 + 25) +} > my.f2(runif(3), 1:4) > debug(my.f2) > my.f2(runif(3), 1:4) > undebug(my.f2) > # insertar un browser() y correr de nuevo

> system.time( ) > system.time(my.f2(runif(10000 ),rnorm(10000))) > proc.time > traceback()

“Q” para salir. Nos dice la duración de la ejecución de una función

Cuando se produce un error, esta función nos hace un trazao de la secuencia de llamadas antes del crash. Until cuando se producen mensajes de error incomprensibles

Ejecución no interactiva Podemos ejecutar código R fuera del intérprete inmediato. Para ello dispone de dos comandos clave, el source y el BATCH Con ellos podemos crear paquetes con nuestras propias funciones que se comporten igual que los demás paquetes. (Ver Writing R extensions). > source("mi.fichero.con.codigo.R")

Abre una sesión de R Es en ocasiones más útil porque inmediatamente de errores en el código.

informa

129

> Rcmd BATCH mi.fichero.con.codigo.R > Rcmd BATCH --help > source(my.file.R, echo = TRUE) > sink

BATCH no informa, pero no requiere tener abierta una sesión (se puede correr en el background). Consulta ayuda de BATCH Para visualizar resultados puede que necesitemos escribir explícitos print statements, o bien usar este comando que los evita . Es el inverso de source (lo manda todo a un fichero).

Ejemplo de programa con bucles y condicionales Vamos a hacer un sencillísimo programa de introducción que cree un vector de 10 componentes siguiendo una distribución uniforme entre 0 y 10, otro con sus cuadrados y un tercero que escriba 0 si es menor o igual que 5 y 1 si es mayor que 5.

> x<-runif(10,0,10) >x

> x<-as.integer(x)

Crea un vector x de 10 componentes aleatorias, siguiendo una distribución uniforme entre 0 y 10. [1] 3.338685 1.003573 9.062377 1.836402 2.670441 3.681082 5.213718 1.396198 [9] 2.036166 7.218985 Los convierte en enteros, por lo que les trunca la parte decimal

>x [1] 3 1 9 1 2 3 5 1 2 7 > y<-x^2 Para calcular los cuadrados no hace falta bucle >y [1] 9 1 81 1 4 9 25 1 4 49 > for(i in 1:length(x)) {z[i]<- Uso bucle for y condicional ifelse para asignarle 0 o 1 a un vector ifelse(x[i]<=5,0,1)} z en funcion de los valores de x [1] 0 0 1 0 0 0 0 0 0 1 > for(i in 1:length(x)) { El mismo programa pero con if + if(x[i]<=5) z[i]=0 + else z[i]=1 +} >z [1] 0 0 1 0 0 0 0 0 0 1 > X <-cbind(x,y,z) Creamos una matriz X con columnas x y z >X x y z [1,] 3 9 0 [2,] 1 1 0 [3,] 9 81 1 [4,] 1 1 0 [5,] 2 4 0 [6,] 3 9 0 [7,] 5 25 0 [8,] 1 1 0 [9,] 2 4 0 [10,] 7 49 1

130

LIBRERIAS DE FUNCIONES PARA MERCADOS FINANCIEROS Fuente http://analisisydecision.es/

Existe en el repositorio algunas librerías específicas para mercados financieros. Nosotros vamos a utilizar dos que deberás instalar: •

quantmod

•

tawny

La manera de funcionar es que conectan a la fuente de datos de los portales de Yahoo y Google, y extrae los datos que le pidamos con unos 15-30 minutos de retraso respecto al tiempo real de mercado (creo que conecta con Yahoo por defecto). Sea como sea, nos indica también la fecha y hora de la última cotización más reciente. Es tan sencillo como hacer: > getQuote('AAPL')

nos informa de la última cotización de las acciones de APPLE. Low

Trade Time Volume

Last Change % Change

AAPL 2015-03-18 02:57:00 128.369 127.25 128.58 126.37 40338298

1.329

Open

High

+1.046%

El ligero inconveniente es que siempre vamos a depender de la conectividad a Yahoo o Google, si ellos dejan de recibir datos, nosotros también. Un apunte importante, para las acciones americanas solo basta escribir su 'ticker' (código de 3 o 4 letras que identifica a las acciones de una compañía) tal cual, pero para el resto de paises es otra historia, hemos de añadir su 'destino'. Aquí os facilito una breve guía: •

.MC para el Mercado Continuo español.

•

.PA si cotiza en Paris

•

.DE si cotiza en Alemania (Deutschland)

•

.MI si cotiza en Milan

•

.LS si cotiza en Lisboa

Así tenemos, por ejemplo (): > getQuote('C+SAN.MC+BNP.PA+ DBK.DE+BES.LS')

Obtenemos las SANTANDER, BNP ESPIRITU SANTO

cotizaciones CITIGROUP, PARIBAS, DEUTSCHE BANK,

BANCO BANCO

La lista de valores la podemos separar por ';' o '+', aunque 131

puede que NO sea la única manera. Consulta el manual >getQuote('^IBEX;^GDAXI;^F CHI;^STOXX50E;^DJI;^IXIC;^ GSPC;^N225;^BVSP;EURUSD= X;GBPEUR=X;USDJPY=X')

listado de índices europeos (4), americanos (3) , Japón, Brasil y algunos pares de divisas

La función 'getQuote' solo nos informa de la cotización más reciente. Ejemplo con las 'Starbucks': > getSymbols("SBUX")

> head(SBUX)

Para extraer un histórico especificando el inicio y final de fechas, si NO indicamos final extrae hasta el último cierre de día (este histórico NO incluye la cotización del día presente en curso), y si NO especificamos el inicio de la serie histórica nos dará el primer día de enero de 2007. visualiza unas líneas del inicio de la serie

> tail(SBUX)

visualiza unas líneas del final de la serie

> getSymbols("SBUX",from="201 0-01-01")

extrae un detalle desde una fecha hasta el último (formato de fechas "yyyy-mm-dd")

> chartSeries(SBUX)

> addRSI()

Añade una ventana con el oscilador RSI

> addBBands()

Añade las bandas de Bollinguer

> addADX()

Añade el oscilador ADX

> saveChart(.type = "pdf", dev = dev.cur())

guardamos el gráfico en '.PDF' [1] chart saved to SBUX.pdf

132

Resultando finalmente un gráfico 'chart' , donde creamos algunos de sus indicadores más clásicos (RSI, Bollinger Bands y ADX):

> addRSI()

Añade una ventana con el oscilador RSI

> addBBands()

Añade las bandas de Bollinguer

> getSymbols("SBUX",from="201 4-01-01",to="2014-12-31")

Si quisieramos concretar el rango temporal basta con definirlo (ejemplo sólo año 2014)

133

> getQuote('TEF.MC',what=yahoo QF())

Para filtrar la información (columnas) a extraer podemos usar la función 'yahooQF()'

Yahoo Finance incluye, además, datos fundamentales de muchos activos financieros, podríamos consultar dividendos y más... > getDividends('SBUX') > getPortfolioReturns("SBUX", obs = 30)

Nos da el histórico de dividendos que una compañía ha repartido a sus accionistas Nos da los rendimientos diarios de los últimos 30 días o desde un fecha anterior hasta fecha reciente

> getPortfolioReturns("SBUX", start = "2010-03-01", end = Sys.Date()) > getIndexComposition('^DJI')

Nos da el listado de compañías que cotizan en el Dow Jones '^DJI'

> getIndexComposition('^GSPC')

Nos da el listado de compañías que cotizan en el S&P 500 '^GSPC'

> getSymbols("VXX",from='2009-

Podemos cargar datos de algunos fondos para estar cortos y beneficiarse de caídas del mercado ('CZI','FAZ',LHB',ERY'...) 134

01-01')

como en este ejemplo el 'VXX'

> chartSeries(VXX)

Lo que tenemos que tener muy claro es que cada vez que usemos el 'ticker' para cualquier función gráfico a extraer, éste hace referencia al objeto memorizado de la última vez que lo definimos como símbolo con 'getSymbols'. Si cambiamos el rango temporal a uno muy corto, solo 'graficaremos' un chart sobre ese corto espacio temporal, su respectivo histórico de dividendos también estará sujeto a dicho espacio, etc. En caso de ignorar algún 'ticker' o el código de algún índice o cualquier producto financiero, lo mejor es remitirse a Yahoo y/o Google. Como hemos visto, lo que aquí R nos puede ofrecer es la facilidad de seguir un listado de 'stocks' y/o índices de diferentes países, divisas, conocer su histórico (lo podemos reducir a rangos cerrados de años atrás), y sobretodo graficar 'charts' con sus indicadores técnicos 'chartistas' sin coste alguno (hay quienes pagan por aplicaciones tipo MetaStock), aunque uno muy bueno para 'stocks' americanos se ofrecen gratis en http://www.stockcharts.com No así en Europa, donde es difícil tener juntos 'stocks' de tan diferentes mercados (y a veces gráficos muy pobres). Bastante bueno pero pobre en gráficos es www.boursorama.com Comentan que existe una aplicación para R que lee datos de Bloomberg con sus propios tickers

135

“Random walk” también se escribe con R. Vamos a escribir un programa que realice un paseo aleatorio de la siguiente forma: i.

Partimos del punto del plano (0,0)

ii.

Vamos a realizar 1000 movimientos en 1000 pasos

iii.

En cada movimiento subiremos o bajaremos en base a un número p tomado aleatoriamente en una distribución uniforme entre [0,1]. Si el número resulta menor que 0,5 entonces subimos y si resulta mayor o igual, entonces bajamos.

iv.

Para calcular cuanto subimos o bajamos, tomamos otro número q aleatorio en una distribución normal N(0.75,0.60) estimado para el IBEX en los últimos 2 años

Dibujamos los 1000 puntos resultantes en un grafico

El programa o script para R podría ser: # ............................................................................................... # ................ Funcion RWstep .................................................. # ............................................................................................... RWstep <- function(pwin=0.5) { # Defino la funcion RWstep que calcula el movimiento en cada paso de la serie (>0 ó <0) # ...pwin .................... es la probabilidad de ganar (0.5 por defecto) # ...p ....................... es en valor aleatorio siguiendo Dist. Uniforme en [0,1] # ...q

....................... es en valor aleatorio siguiendo Dist. N [μ=0.75,σ=0.60] p <- runif(1,0,1) q<-rnorm(1,0.75,0.60) ifelse (p<pwin, +q, -q)

} # ............................................................................................... # ................ Funcion RWalk RandomWalk .................................................. # ............................................................................................... RWalk <- function(nsteps =500,pwin=0.5) { # Define el camino aleatorio en un vector y de nsteps componentes # ...nsteps ................. es el numero de pasos a recorrer (default 500) # ...pwin .................... es la probabilidad de ganar (default 0.5) y <- rep(0,nsteps) y[1] <- 0 for(i in 2:nsteps) { y[i] = y[i-1] + RWstep(pwin) } return(y) }

136

# ............................................................................................... # ................... Funcion Dibuja Random Walk ................................. # ............................................................................................... DrawRW <- function (nsteps,pwin) { # ..... nsteps son los pasos (default 500) # ..... Pwin es la probabilidad de ganar (default 0.5) x <- 1:nsteps y <- 1:nsteps x[1] <- 0 y[1] <- 0 y <- RWalk(nsteps,pwin = 0.5) plot(x,y,type="l") } # ..... Y cada vez que queramos dibujar un Random Walk .................... DrawRW (2000,0.51) Lo ejecutamos y obtenemos este grรกfico:

137

Y este otro con 5000 pasos (unos 20 a単os)

138

COMBINATORIA El análisis combinatorio, sorprendentemente, no viene incluido en el módulo base de R, tenemos que cargar la librería combinat Esta librería, aparte de otras funciones más avanzadas, incluye las combinaciones y las permutaciones sin repetición

install.packages("combinat") require(combinat) nCm(4,2) choose(n,m)

combn(3, 2)

x<c("blanca","azul","roja","verde")

Carga el paquete copmbinat que incluye algunas funciones de combinatoria Nos da el resultado del número combinatorio C3,2 [1] 6 La función choose equivale a nCm o el binomio de n sobre m y viene en el CORE [1] 6 Va más allá y nos escribe cuales son esas combinaciones: [,1] [,2] [,3] [,4] [,5] [,6] [1,] 1 1 1 2 2 3 [2,] 2 3 4 3 4 4 [,1] [,2] [,3] [,4] [,5] [,6] [1,] "blanca" "blanca" "blanca" "azul" "azul" "roja" [2,] "azul" "roja" "verde" "roja" "verde" "verde"

> combn(x,2) x<-c("blanca","azul","roja") permn(3)

factorial(5)

[[1]] [1] "blanca" "azul" "roja" [[2]] [1] "blanca" "roja" "azul" [[3]] [1] "roja" "blanca" "azul" [[4]] [1] "roja" "azul" "blanca" [[5]] [1] "azul" "roja" "blanca" [[6]] [1] "azul" "blanca" "roja" Calcula el factorial de un número <-> 5! [1] 120

Pero todavía nos faltan las variaciones con y sin repetición y el caso especial de las permutaciones con repetición. Y ocurre que tampoco están es este paquete pero sí en otro paquete del repositorio llamado gtools, install.packages("gtools")

Carga el paquete copmbinat que incluye algunas funciones de combinatoria 139

require(gtools) permutations(n=3,r=2,v=x, repeats.allowed=FALSE)

permutations(n=3,r=2,v=x, repeats.allowed=T)

> x <- c('rojo', 'azul', 'verde') > combinations(n=3, r=2, v=x, repeats=FALSE)

> combinations(n=3, r=2, v=x, repeats=TRUE)

> nrows(combinations(n=3, r=2, v=x, repeats=FALSE))

Nos da el resultado de todas las variaciones sin repeticion del vector x tomandos de 2 en 2 [,1] [,2] [1,] "azul" "blanca" [2,] "azul" "roja" [3,] "blanca" "azul" [4,] "blanca" "roja" [5,] "roja" "azul" [6,] "roja" "blanca" Nos da el resultado de todas las variaciones con repeticion del vector x tomandos de 2 en 2 [,1] [,2] [1,] "azul" "azul" [2,] "azul" "blanca" [3,] "azul" "roja" [4,] "blanca" "azul" [5,] "blanca" "blanca" [6,] "blanca" "roja" [7,] "roja" "azul" [8,] "roja" "blanca" [9,] "roja" "roja" Nos da las Combinaciones sin repetición [,1] [,2] [1,] "azul" "rojo" [2,] "azul" "verde" [3,] "rojo" "verde" Nos da las combinaciones con repetición [,1] [,2] [1,] "azul" "azul" [2,] "azul" "rojo" [3,] "azul" "verde" [4,] "rojo" "rojo" [5,] "rojo" "verde" [6,] "verde" "verde" El núemro de filas de estas matricez resultantes nos dirían cuántas son. [1] 3

Pero no el valor, y a estas alturas de la película, no hemos encointrado todavía las permutaciones con repetición. La función choose()

140

MĂ&#x2030;TODOS NUMĂ&#x2030;RICOS para ecuaciones no lineales Si queremos resolver un sistema de ecuaciones lineales ya hemos visto que lo podemos hacer matricialmente con el comando solve() pero no hemos hablado nada de resolver ecuaciones no lineales

En el paquete base podemos encontrar optim > x<-c(36,-9,-4,1) > polyroot(x) [1] 3+0i -3+0i 4-0i uniroot (method Newton Raphson) large systems of Nonlinear equations solving Paquete nleqslv package rootsolve

141

ESTADÍSTICA con R Estadistica descriptiva con R R incorpora todas las funciones necesarias para hacer un trabajo de Estadística Descriptiva, tanto la más simple como librerías las más avanzadas técnicas del más alto nivel de investigaón. Vamos a hacer una hoja de trabajo introductoria de Etadística Descriptiva simple en la que vamos a ir viendo las funciones incluidas en el CORE de R:

> x<-rrnorm(50)

> round(x,digits=3)

> sample () > mean(x) > var(x) > sd(x) > median(x) > quantile(x)

> sum(x) > sumcum(x) > prod(x) > weigthed.mean( ) > IRQ( )

Creo 50 valores aleatorios que siguan una curva normal Al no decir nada se trata de una normal de media 0 y desviación típica 1, es decir una N(0,1) Redondea los datos x a solo 3 decimales [1] 0.504 0.380 0.020 0.702 0.412 0.403 -0.076 -1.159 -1.065 -0.924 [11] 0.458 1.644 -2.286 -0.756 -0.691 -0.215 0.227 -0.691 0.254 0.092 [21] 1.059 -0.756 0.607 0.921 0.061 0.041 -0.246 -0.199 -0.615 1.190 [31] 0.037 -1.490 -1.212 -0.209 -1.688 -0.353 -1.034 -0.642 -0.687 -0.582 [41] -1.978 0.218 0.568 -2.385 -1.547 0.619 -0.358 -2.901 -0.325 -1.301 Crea un vector de muestras aleatorias Calcula la media 0.3590638 Calcula la varianza [1] 0.9152149 Calcula la desciación estándar [1] 0.9566687 Calcula la mediana [1] -0.2302299 Calcula los 5 cuantiles. recuerda que el cuantil 50% coincide con la mediana 0% 25% 50% 75% 100% -2.9006401 -0.8819996 -0.2302299 0.3483420 1.6435302 Suma de los valores de la variable x Suma acumulativa de los valores de la variable x Producto de los valores de la variable x Media ponderada

> min(x) > max(x) > range(x)

Mínimo de los elementos del vector x Máximo de los elementos del vector x Rango de los elementos del vector x

> tapply(x,f)

Para obtener resumenes por grupos se usan las funciones de la familia apply( ), en poarticular la tapply( ) Correlación entre los vectores x e y. Admite un solo argumento

> cor (x,y)

142

Ahora vamos a importar de Excel un Base de Datos de 5 variables y un Identificador llamada clase.csv

Importamos esta hoja

> read.csv("clase.csv",header="T")

R lee la base de datos clase.csv y conserva los titulos. Ojo que el separador de decimales hay que configurarlo como "." n lugar de "," para que haya compatibilidad con tipo csv ID Male edad peso talla PAS 1 1 0 23 66.5 1.50 1.92 2 2 1 28 64.0 1.88 1.81 3 3 1 38 84.3 1.61 1.42 4 4 1 19 54.0 1.68 1.45 5 5 0 46 75.0 1.67 1.81 6 6 1 34 51.0 1.73 1.76 7 7 1 47 70.0 1.72 1.70 8 8 0 28 49.0 1.79 1.90 9 9 0 49 NA 1.83 1.65 10 10 0 31 73.0 1.79 1.92 11 11 1 28 56.0 1.63 1.99 12 12 0 29 50.0 1.67 1.56 13 13 0 24 67.0 1.71 1.64 14 14 1 21 58.0 1.82 1.97 15 15 0 21 74.0 1.91 1.84 16 16 1 24 87.0 1.89 1.94 17 17 1 36 85.0 1.82 1.51 18 18 0 31 48.0 1.87 1.63 19 19 0 36 56.0 1.79 1.40 20 20 0 30 59.0 1.58 1.81 21 21 1 25 76.0 1.86 1.60 22 22 0 37 71.0 1.52 1.97 23 23 1 27 62.0 1.61 1.88 24 24 0 34 88.0 1.70 1.51 25 25 1 38 62.0 1.62 1.97 143

> clase<- Asigno a la variable clase la matriz leida read.csv("clase.csv",header="T") Hacemos un sumario estadísto de cada columna de la matriz > summary(clase) clase

> mean(edad)

Iq uiero calcular la media tan solod e la columna edad nos sale un error porque clase es un todo y R no conoce las columnas como variables Error en mean(edad) : objeto 'edad' no encontrado >attach(clase) Con el comando attach descompone en variables cada columna >mean(edad) Ahora si sabe calcular la media de edad [1] 31.36 > mean(peso) Inicialmente hay un valor de peso que no está "NA" [1] NA > mean(peso,na.rm=T) Si al comando mean le añadimos que borre los que tienen NA entonces si que lo calcula bien [1] 66.075 > clase<- 0 es mujer y 1 es hombre. Para evitar olvidar estas cosas transform(clase,Male=factor(Male podemos usar etiquetas "F" y "M" ,labels=c("F","M"))) > summary(clase)

Ahora ya aparecen las mujeres como "F" y los hoimbres como "M" computados

Vamos a hacer un segundo trabajo de Estadística Descriptiva haciendo finalmente un gráfico

> resp<c("si","no","si","si","si","no","si","n o","si") > table(resp)

Crea un vector de contiene 10 respuesta a una encuesta con una variable cualitativa de posibles respuestas únicamente "si" o "no" Nos hace una tabla donde calcula que 3 personas contestaron no y 7 contestaron si resp 144

no si 3 6 > sueldo<- Creamos una variable cuantitativa numerica con los sueldos c(10.5,2,0.6,15,3.5,6,6,7,5.5,0.7) de 10 personas. > range(sueldo) Preguntamos el ranbo [1] 0.6 15.0 > table(sueldo) R nos muestra que 2 personas ganan 6 y el resto son cantidades diferentes sueldo 0.6 0.7 2 3.5 5.5 6 7 10.5 15 1 1 1 1 1 2 1 1 1 > catg<-cut(sueldo,breaks<- Si en lugar de 10 hubiese miles de valores cuantitativos c(0,5,10,max(sueldo))) tendrĂamos que hacer intervalos > catg [1] (10,15] (0,5] (0,5] (10,15] (0,5] (5,10] (5,10] (5,10] (5,10] [10] (0,5] Levels: (0,5] (5,10] (10,15] > table(catg) catg (0,5] (5,10] (10,15] 4 4 2 > levels(catg) [1] "(0,5]" "(5,10]" "(10,15]" > levels(catg)<- Podemos darle nombres a los intervalos c("bajo","medio","alto") > table(catg)

> table(resp,catg) > barplot(table(resp))

catg bajo medio alto 4 4 2 No me funciona pero deberĂa mixturar ambas variables

145

> barplot(table(catg))

> barplot(sueldo)

> catg.counts<-table(catg) > pie(catg.counts

146

> hist(sueldo)

> boxplot(sueldo)

> boxplot(sueldo,horizontal=T,col=" green")

147

> plot(sueldos)

> plot(sueldo,type="o",col="red")

148

BIBLIOGRAFÍA R para principiantes, de Emmanuel Paradis (2003, Universit Montepellier II). Traducido por J. An Introduction to R, del R Development CORE team; existe traducción al castellano Curso de Introducción a R por David V. Conesa Guillén ( 5 sesiones y ejercicios) Febrero Bande, M.; Galeano San Miguel, P.; González Díaz, J. y Pateiro López, B., (2008). Prácticas de Estadística en R. Departamento de Estadística e Investigación Operativa de la Universidad de Santiago de Compostela. ISBN: 978-84-691-0975-1. DL: C-350-2008. Febrero Bande, M.; Galeano San Miguel, P.; González Díaz, J. y Pateiro López, B., (2008). Estadística. Departamento de Estadística e Investigación Operativa de la Universidad de Santiago de Compostela. ISBN:978-84-691-0974-8. DL: C-351-2008. Arriaza A. J., Fernández F. (2008). Estadística Básica con R y R-Commander (*) A guide for the unwilling S user, de P. Burns. En •

http://cran.r-project.org/doc/contrib/Burns-unwilling_S.pdf

•

http://www.burns-stat.com/pages/tutorials.html

¡Sólo 8 páginas!

Ahumada (University of Hawaii & National Wildlife Health Center). • •

http://cran.r-project.org/other-docs.html http://cran.r-project.org/doc/contrib/rdebuts_es.pdf.

FAQ. S Programming, de W. Venables y B. Ripley. •

http://www.stats.ox.ac.uk/pub/MASS3/Sprog

W. J. Owen 2006. The R Guide •

http://cran.r-project.org/doc/contrib/Owen-TheRGuide.pdf

Tom Short 2004. R Reference Card •

http://cran.r-project.org/doc/contrib/Short-refcard.pdf

Publicaciones de la Universidad de Cádiz. Disponible en: •

http://knuth.uca.es/repos/ebrcmdr/pdf/actual/ebrcmdr.pdf

Castiglia, V. (3ª edición, 2001). Principios de Investigación Biomédica. Gráfica Sur Editora. Crawley, M. J. (2007). The R Book. •

http://archive.org/stream/TheRBook/The_R_Book-Crawley#page/n0/mode/2up

149

Contreras García, J.M.; Molina Portillo, E.; Arteaga Cezón, P. (2011) Introducción a la programación estadística con R para profesores. ISBN: 978-84-693-4859-8. Correa, J.C. y González, N., (2002). Gráficos Estadísticos con R. Universidad Nacional-Sede Medellín. •

http://cran.r-project.org/doc/contrib/grafi3.pdf

Campbell, S.K. (1990). Equívocos y falacias en la interpretación de Estadísticas. • http://matematicas.reduaz.mx/home/Docentes/ltrueba/extras/Equiv.ppt Domingo Giménez, A., Lógica matemática. • http://www.monografias.com/trabajos-pdf3/logica-matematica/logica-matematica.pdf Everitt, B. S. y Hothorn, T., (2006). A Handbook of Statistical Analyses Using R. • http://cran.r-project.org/web/packages/HSAUR/vignettes/Ch_introduction_to_R.pdf González Carmona, A. y González, S., (2000). Introducción a R. • http://cran.rproject.org/doc/contrib/R-intro-1.1.0-espanol.1.pdf Ihaka R., Gentleman R. (1996). R: A Language for Data Analysis and Graphics. • http://www.stat.auckland.ac.nz/~ihaka/downloads/R-paper.pdf Kabakov, Robert I. (2011) R in Action. Data analysis and graphics with R. Ed Manning USA Maindonald, J. y Braun, J. (2007). Data Analysis and Graphics Using R. Cambridge University Press. • http://cran.r-project.org/doc/contrib/usingR.pdf Matloff, Norman. (2011) The art or R programming. A tour of statistical software design. Mpt Starch Press Mendenhal, W. Sincich, T., Ciencias (4ª edición, 1997). Probabilidad y Estadística para Ingeniería. Editorial Thomson. México, 2002. Navidi, W. (3ª edición, 2010). Estadística para ingenieros y científicos. ISBN: 0073376337 Ortega Sánchez, J. (2009). Introducción a R. Centro de Investigación Operativa en Matemáticas de Guanajuato (Méjico). • http://www.cimat.mx/~jortega/ R. Risk, M. (2003). Cartas sobre Estadística de la Revista Argentina de Bioingeniería Facultad Regional de Buenos Aires. Universidad Tecnológica Nacional. ISBN: 987-43-6130-1. • http://cran.r-project.org/doc/contrib/Risk-Cartas-sobre-Estadistica.pdf Rice, John A. (3ª edición, 2006). Mathematical Statistics and Data Analysis. ISBN-10: 0534399428. ISBN-13: 978-0534399429 Romero-Zaliz, R. (2005). Reconocimiento de Perfiles de Regulación Genética mediantealgoritmos evolutivos multiobjetivo. Departamento de Ciencias de la Computación e Inteligencia Artificial de la Universidad de Granada 150

•

http://decsai.ugr.es/~rocio/tesis.pdf

Ryan TP. (1997) Modern Regression Analysis for Scientists and Engineers. Disponible en: • http://www.itl.nist.gov/div898/education/ryannotes.pdf Sáez Castillo, A. J. (2010). Métodos Estadísticos con R y R Commander. Departamento de Estadística e Investigación Operativa de la Universidad de Jaén. Disponible en: • http://cran.rproject.org/doc/contrib/Saez-Castillo-RRCmdrv21.pdf Serrano Pérez, M. C. (2010). Álgebra matricial con Octave. Cálculo Numérico. Introducción a Matemática. Departamento de Matemática Aplicada de la Universidad de Granada. • http://seneca.ugr.es/ Wilhelmi, Miguel R. (2004). Combinatoria y Probabilidad. Departamento de Didáctica de Matemáticas de la Universidad de Granada. ISBN: 978-84-933-517-0-9. Dep. Legal: GR849/04.

Web´s recomendadas http://www.r-project.org/ (****) http://www.rseek.org/ http://wapedia.mobi/es/R-project http://analisisydecision.es/ (****) http://www.grserrano.es/ http://r-es.org http://ereros.forja.rediris.es http://ereros.org http://erre-que-erre-paco.blogspot.com.es/ https://sites.google.com/site/elestadisticoerrante/ http://recursostic.educacion.es http://rprojectsp.blogspot.com.es/ http://www.cyclismo.org/tutorial/R/ http://www.r-bloggers.com/ http://manuals.bioinformatics.ucr.edu/home/programming-in-r http://halweb.uc3m.es/esp/Personal/personas/jmmarin/esp/ManualR/intro_programa.htm http://www.statmethods.net/ (****) http://www.datanalytics.com/2015/03/25/pues-si-un-curso-de-redes-sociales-con-r/ http://www.datanalytics.com/2011/08/05/svd-de-matrices-enormes-con-r/ (****) https://sevillarusers.wordpress.com https://ryouready.wordpress.com/ https://blogisticreflections.wordpress.com/ http://freakonometrics.hypotheses.org https://learnr.wordpress.com/ http://onertipaday.blogspot.com.es/ http://emilopezcano.blogspot.com.es/ http://www.seio.es/ (****) http://comments.gmane.org/gmane.comp.lang.r.general/248655 http://www.mayin.org/ajayshah/KB/R/ http://knuth.uca.es/R/doku.php http://www.twotorials.com/ http://www.screenr.com/tVT8 https://r-forge.r-project.org/softwaremap/trove_list.php?form_cat=307 (incluye bibliotecas finanzas) 151

Foros de ayuda Español http://knuth.uca.es/moodle/mod/forum/view.php?id=807 Inglés https://r-forge.r-project.org/forum/forum.php?forum_id=78&group_id=34 https://drive.google.com/open?id=0B5tmELxA79GEeEFyM1RmemllZk0&authuser=0 http://care.live-analytics.com/discussions/suggestions/24-live-r-new-packages-request

Lista de correo de ayuda Español (previo registro) r-help-es@r-project.org Inglés (previo registro) r-help@r-project.org

Vídeos YouTube 5 Videos muy didácticos de Miguel Castiella de la Universidad de Deusto https://www.youtube.com/watch?v=WmkRHVXsM08 La profesora Bebilda nos ofrece este canal con 29 videos todos muy aprovechables https://youtu.be/PUaE1f-0NrA?list=PL7DA3FDA21A1A6310

Autores de las Fuentes David Valentín Conesa Guillen Dept. Estadística i Investigació Operativa Universitat de Valencia David.V.Conesa@uv.es Teléfono (34) 963 543 791 Juan José Gibaja Martins Universidad de Deusto jjgibaja@deusto.es Daniel Fernández http://analisisydecision.es/ Raúl Vaquerizo http://analisisydecision.es/ Emilio Torres Manzanera Departamento de Estadística e Investigación Operativa y Didáctica de la Matemática Universidad de Oviedo. torres@uniovi.es G R Serrano http://www.grserrano.es/ Manuel Febrero Bande Departamento de Estadística e Investigación Operativa. Universidad de Santiago USC manuel.febrero@usc.es Xavier Solé y Juan Vals R Joaquin Ortega Sanchez Francesc Carmona Universidad de Barcelona fcarmona@ub.edu

Cursos on line de R https://www.datacamp.com/courses http://www.mbitschool.com/courses/big-data-analytics http://sentimentmining.net/StatisticsWithR/ 152

Juan Jose Gibaja Martins (jjgibaja@deusto.es) 0 1 2 3 4 5

de de de de de de

5 5 5 5 5 5

Curso Curso Curso Curso Curso Curso

R R R R R R

Presentacion Curso R https://youtu.be/eTtIT35z_jA Introducción https://youtu.be/dpiApWbgSw8 Infraestructura https://youtu.be/WmkRHVXsM08 Importar y Exportar https://youtu.be/77tTfjx5hhs Tipos y estructuras de datos , https://youtu.be/U4uO4TIIzjs Análisis de datos https://youtu.be/uK31EnqbHHQ

Como hacer manuales con R y Latex https://www.gnu.org/software/texinfo/ http://en.wikipedia.org/wiki/PdfTeX https://tug.org/ http://texstudio.sourceforge.net/ http://cran.r-project.org/doc/manuals/r-release/R-admin.html#Making-the-manuals http://www.latex-project.org/

R siempre a mano (R en la nube) Fuente G R Serrano http://www.grserrano.es/ Últimamente se han puesto en marcha dos servicios de R en la nube, ambos interesentes aunque con distinta orientación. El primero que quiero comentar es R-Fiddle, http://www.r-fiddle.org, que permite compartir y ejecutar código en R. Como se aprecia en la siguiente captura de pantalla, dispone de un editor y una consola, además de abrir ventanas para las salidas gráficas. Una vez probado el código, es sencillo compartirlo mediante enlaces cortos. Por ejemplo, http://www.r-fiddle.org/#/fiddle?id=sWo0ETtI&version=1 enlaza a un ejemplo que preparé para mis estudiantes de econometría. El segundo servicio es StatAce, que tiene una orientación más profesional (con planes gratuitos y de pago), en la línea de RStudio Server pero alojado. Acostumbrado a RStudio, me resulta algo incómoda su interface, pero es cuestión de minutos hacerse con ella. Se presenta en forma de IDE, con distintas ventanas para editar, memoria, salidas … 153

No he hecho pruebas extensivas y ambos son beta, es decir, todavĂa se producirĂĄn problemillas, pero resultan funcionales y muy prĂĄcticos si no se dispone de un servidor con R accesible desde internet o para tutoriales y listas de ayuda.

154