El Programa R, Herramienta Clave en Investigación - Carlos Redondo Figuero PDF

El programa R,
herramienta clave
en investigación
Carlos G. Redondo Figuero
Ciencias Experimentales
Textos Universitarios
EL PROGRAMA R,
HERRAMIENTA CLAVE EN INVESTIGACIÓN
Colección M ANUALES #54: Textos Universitarios 23
CONSEJO EDITORIAL
Dña. Sonia Castanedo Bárcena

Presidenta del Consejo Editorial. Secretaria General, Universidad de Cantabria
D. Vitor Abrantes
Facultad de Ingeniería, Universidad de Oporto
D. Miguel Ángel Bringas Gutiérrez
Dpto. de Economía, Universidad de Cantabria
D. Fidel Ángel Gómez Ochoa
Dpto. Historia Moderna y Contemporánea, Universidad de Cantabria
D. Jesús González Macías
Dpto. Medicina y Psiquiatría, Universidad de Cantabria
D. José Manuel Goñi Pérez
Modern Languages Department, Aberystwyth University
D. Salvador Moncada
Dpto. de Farmacología, Universidad de Mánchester
Dña. Cecilia Pola Méndez
Dpto. Matemáticas, Estadística y Computación, Universidad de Cantabria
D. Marcelo Norberto Rougier
CONICET (IIEP) y Dpto. Historia Económica y Social Argentina, UBA
D. Carlos Marichal Salinas
Centro de Estudios Históricos COLMEX
Dña. Claudia Sagastizábal
Visiting Researcher en el IMPA (Instituto Nacional de Matemática Pura e Aplicada)
D. Luis Villegas Cabredo
Director del Grupo I+D GTED-UC
Dña. Belmar Gándara Sancho
Directora Editorial, Universidad de Cantabria
EL PROGRAMA R,
HERRAMIENTA CLAVE EN INVESTIGACIÓN
Textos Universitarios, nº 23
Ciencias Experimentales
Editorial
Universidad
Cantabria
Redondo Figuero, Carlos
El programa R, herramienta clave en investigación [Recurso electrónico] /
Carlos G. Redondo Figuero. – Santander : Editorial de la Universidad de Canta-
bria, 2017.
XIV, 410 p. : il. – (Manuales ; 54. Textos universitarios ; 23 )
ISBN 978-84-8102-808-9
1. R (Programa de ordenador). 2. Estadística – Informática.
004.438 R
311:004.6
ibiC: YQtU, Pbt, Mbns, 4GE
Esta edición es propiedad de la Editorial dE la UnivErsidad dE Cantabria, cualquier forma

de reproducción, distribución, traducción, comunicación pública o transformación solo puede
ser realizada con la autorización de sus titulares, salvo excepción prevista por la ley. diríjase
a CEdro (Centro Español de derechos reprográficos, www.cedro.org) si necesita fotocopiar
o escanear algún fragmento de esta obra.
© Carlos Godofredo redondo Figuero

© Editorial de la Universidad de Cantabria
avda. de los Castros, 52 - 39005 santander, Cantabria (España)
www.editorialuc.es
isbn: 978-84-8102-808-9 (PdF)

isbn: 978-84-8102-797-6 (rústiCa)
santander, 2017
Hecho en España - Made in Spain
www.editorialuc.es
Índice general
1. El método cientı́fico 1
1.1. Introducción . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
1.2. El Método Cientı́fico . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.2.1. Hacer ciencia . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.3. Fundamentos filosóficos . . . . . . . . . . . . . . . . . . . . . . . 3
1.3.1. Los inductistas . . . . . . . . . . . . . . . . . . . . . . . . 3
1.3.2. Los refutacionistas . . . . . . . . . . . . . . . . . . . . . . 4
1.4. Fases del Método Cientı́fico . . . . . . . . . . . . . . . . . . . . . 4
1.4.1. Pregunta de investigación . . . . . . . . . . . . . . . . . . 5
1.4.2. Búsqueda bibliográfica . . . . . . . . . . . . . . . . . . . . 6
1.4.3. Hipótesis y objetivos . . . . . . . . . . . . . . . . . . . . . 7
1.4.4. Experimento . . . . . . . . . . . . . . . . . . . . . . . . . . 7
1.4.5. Base de datos . . . . . . . . . . . . . . . . . . . . . . . . . 8
1.4.6. Análisis estadı́stico . . . . . . . . . . . . . . . . . . . . . . 9
1.4.7. Publicación . . . . . . . . . . . . . . . . . . . . . . . . . . 10
1.5. La necesidad de investigación . . . . . . . . . . . . . . . . . . . . 10
1.6. Caracterı́sticas para ser un buen investigador . . . . . . . . . . . 11
1.7. Investigación de calidad . . . . . . . . . . . . . . . . . . . . . . . 12
I EL PROGRAMA R 15
2. El programa R 17
2.1. Introducción . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
2.2. Caracterı́sticas del sistema R . . . . . . . . . . . . . . . . . . . . . 19
2.3. Obtención de R . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
2.4. Instalación de R y arranque del programa . . . . . . . . . . . . . 20
2.4.1. Instalación de R . . . . . . . . . . . . . . . . . . . . . . . . 20
2.4.2. Arranque de R . . . . . . . . . . . . . . . . . . . . . . . . 20
2.5. Funciones y paquetes en este capı́tulo . . . . . . . . . . . . . . . 23
3. El entorno de programación RStudio 25

3.1. El entorno de programación . . . . . . . . . . . . . . . . . . . . . 25
3.2. Instalación . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
3.2.1. Descarga . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
3.2.2. Iniciando RStudio . . . . . . . . . . . . . . . . . . . . . . 26
3.2.3. Menú principal . . . . . . . . . . . . . . . . . . . . . . . . 26
3.3. Las cuatro ventanas . . . . . . . . . . . . . . . . . . . . . . . . . . 28
Libros de Estadística en PDF | Statistics Books in PDF

II ÍNDICE GENERAL
3.3.1. Ventana ((Source)) . . . . . . . . . . . . . . . . . . . . . . . 28

3.3.2. Ventana ((Console)) . . . . . . . . . . . . . . . . . . . . . . . 29
3.3.3. Ventana ((Environment)) . . . . . . . . . . . . . . . . . . . . 30
3.3.4. Ventana ((Plots)) . . . . . . . . . . . . . . . . . . . . . . . . 30
3.4. Atajos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
3.5. Directorio de trabajo . . . . . . . . . . . . . . . . . . . . . . . . . 34
4. Librerı́as en R 37
4.1. Paquetes instalados . . . . . . . . . . . . . . . . . . . . . . . . . . 37
4.2. Instalación de un paquete . . . . . . . . . . . . . . . . . . . . . . 39
4.3. Actualización de un paquete . . . . . . . . . . . . . . . . . . . . . 39
4.4. Contenido de un paquete . . . . . . . . . . . . . . . . . . . . . . 40
4.4.1. Cabecera de un paquete . . . . . . . . . . . . . . . . . . . 40
4.4.2. ((Datasets)) de un paquete . . . . . . . . . . . . . . . . . . 41
4.4.3. Contenido de todo el paquete . . . . . . . . . . . . . . . . 41
4.5. Paquetes recomendados . . . . . . . . . . . . . . . . . . . . . . . 41
4.5.1. De tipo general . . . . . . . . . . . . . . . . . . . . . . . . 41
4.5.2. De tipo epidemiológico . . . . . . . . . . . . . . . . . . . 42
4.6. Task Views . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
4.7. Funciones en este capı́tulo . . . . . . . . . . . . . . . . . . . . . . 42
5. R calculadora cientı́fica 45
5.1. Introducción . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
5.2. Funciones básicas . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
5.3. Funciones avanzadas . . . . . . . . . . . . . . . . . . . . . . . . . 47
5.3.1. De redondeo . . . . . . . . . . . . . . . . . . . . . . . . . . 47
5.3.2. Matemáticas generales . . . . . . . . . . . . . . . . . . . . 48
5.3.3. Trigonométricas . . . . . . . . . . . . . . . . . . . . . . . . 49
6. El sistema de ayuda en R 53
6.1. Las funciones de ayuda . . . . . . . . . . . . . . . . . . . . . . . . 53
6.1.1. La función ((help())) o ((?)) . . . . . . . . . . . . . . . . . . 53
6.1.2. La función ((help.search())) . . . . . . . . . . . . . . . . . . 54
6.1.3. La función ((help.start())) . . . . . . . . . . . . . . . . . . . 55
6.1.4. La función ((apropos())) . . . . . . . . . . . . . . . . . . . . 56
6.1.5. La función ((example())) . . . . . . . . . . . . . . . . . . . 56
6.1.6. La función ((vignette())) . . . . . . . . . . . . . . . . . . . . 57
6.2. Otras funciones de ayuda . . . . . . . . . . . . . . . . . . . . . . 58
6.2.1. La función ((find())) . . . . . . . . . . . . . . . . . . . . . . 58
6.2.2. La función ((demo())) . . . . . . . . . . . . . . . . . . . . . 58
6.3. La función ((history())) . . . . . . . . . . . . . . . . . . . . . . . . 59
II EL LENGUAJE R 61
7. Guı́a de estilo en R 63
7.1. Nombres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
7.1.1. Ficheros . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63

ÍNDICE GENERAL III
7.1.2. Objetos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64
7.2. Sintaxis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64
www.editorialuc.es
7.3. Escritura de código . . . . . . . . . . . . . . . . . . . . . . . . . . 65
7.4. Documentación . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
8. Sintaxis del lenguaje R 67

8.1. Comandos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67
8.1.1. Expresiones . . . . . . . . . . . . . . . . . . . . . . . . . . 68
8.1.2. Asignaciones . . . . . . . . . . . . . . . . . . . . . . . . . 68
8.2. Operadores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
8.3. Funciones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
9. Objetos 75
9.1. Nombre . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
9.1.1. Palabras reservadas . . . . . . . . . . . . . . . . . . . . . 76
9.1.2. Palabras que deben ser evitadas . . . . . . . . . . . . . . 77
9.2. Memoria . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77
9.3. Propiedades . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79
9.3.1. Atributos . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79
9.3.2. Clase . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81
9.3.3. Dimensiones y Longitud . . . . . . . . . . . . . . . . . . . 81
9.3.4. Nombres . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82
9.3.5. Tipo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83
9.3.6. Modo de almacenamiento . . . . . . . . . . . . . . . . . . 83
9.3.7. Estructura . . . . . . . . . . . . . . . . . . . . . . . . . . . 85
9.4. Manipulación de objetos . . . . . . . . . . . . . . . . . . . . . . . 86
9.4.1. Creación . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86
9.4.2. Coerción . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86
9.4.3. Destrucción . . . . . . . . . . . . . . . . . . . . . . . . . . 89
9.5. Visibilidad . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89
10. Vectores 93
10.1. Concepto . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94
10.1.1. Vectores atómicos . . . . . . . . . . . . . . . . . . . . . . . 94
10.1.2. Listas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94
10.2. Creación de vectores . . . . . . . . . . . . . . . . . . . . . . . . . 94
10.2.1. Concatenación . . . . . . . . . . . . . . . . . . . . . . . . 96
10.2.2. Secuencias . . . . . . . . . . . . . . . . . . . . . . . . . . . 97
10.2.3. Repeticiones . . . . . . . . . . . . . . . . . . . . . . . . . . 98
10.3. Tipos de vectores . . . . . . . . . . . . . . . . . . . . . . . . . . . 99
10.3.1. Lógicos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99
10.3.2. Numéricos . . . . . . . . . . . . . . . . . . . . . . . . . . . 100
10.3.3. Cadena . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102
10.3.4. Listas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103
10.3.5. Elementos especiales . . . . . . . . . . . . . . . . . . . . . 104
10.4. Operaciones con vectores . . . . . . . . . . . . . . . . . . . . . . 106
10.4.1. Poner nombres . . . . . . . . . . . . . . . . . . . . . . . . 106
10.4.2. En vectores numéricos . . . . . . . . . . . . . . . . . . . . 106

IV ÍNDICE GENERAL
10.4.3. En vectores de caracteres . . . . . . . . . . . . . . . . . . 107

10.5. Manipulación de vectores . . . . . . . . . . . . . . . . . . . . . . 109
10.5.1. Extracción de elementos (subsetting) . . . . . . . . . . . . 110
10.5.2. Cambio del valor de algún elemento . . . . . . . . . . . . 111
10.5.3. Ordenación de elementos . . . . . . . . . . . . . . . . . . 112
10.5.4. Eliminación de vectores . . . . . . . . . . . . . . . . . . . 112
10.5.5. Grabación de vectores . . . . . . . . . . . . . . . . . . . . 113
10.6. Funciones vectoriales . . . . . . . . . . . . . . . . . . . . . . . . . 113
11. Factores 119

11.1. Creando factores . . . . . . . . . . . . . . . . . . . . . . . . . . . 121
11.1.1. La función as.factor() . . . . . . . . . . . . . . . . . . 121
11.1.2. La función factor() . . . . . . . . . . . . . . . . . . . . 121
11.1.3. Las función ordered() . . . . . . . . . . . . . . . . . . . 123
11.1.4. La función cut() . . . . . . . . . . . . . . . . . . . . . . . 123
11.2. Tipos de factores . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125
11.2.1. Factores no ordenados . . . . . . . . . . . . . . . . . . . . 125
11.2.2. Factores ordenados . . . . . . . . . . . . . . . . . . . . . . 126
11.3. Uso de factores en estadı́stica . . . . . . . . . . . . . . . . . . . . 126
11.3.1. Combinar niveles . . . . . . . . . . . . . . . . . . . . . . . 126
11.3.2. Cambiar nivel de referencia . . . . . . . . . . . . . . . . . 128
11.3.3. Número de niveles . . . . . . . . . . . . . . . . . . . . . . 128
11.3.4. La función gl() . . . . . . . . . . . . . . . . . . . . . . . 128
11.3.5. La función tapply() de la familia apply . . . . . . . . 129
12. Tablas 133

12.1. La función table() . . . . . . . . . . . . . . . . . . . . . . . . . 133
12.1.1. Tabla de frecuencias . . . . . . . . . . . . . . . . . . . . . 133
12.1.2. Tabla de contingencia . . . . . . . . . . . . . . . . . . . . 134
12.2. La función xtabs() . . . . . . . . . . . . . . . . . . . . . . . . . 136
12.3. La función ftable() . . . . . . . . . . . . . . . . . . . . . . . . 138
13. Listas 141

13.1. Crear . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 144
13.2. Nombrar . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 144
13.3. Indexar . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 145
13.4. Reemplazar componentes de una lista . . . . . . . . . . . . . . . 145
13.5. Operaciones sobre una lista . . . . . . . . . . . . . . . . . . . . . 147
13.6. Eliminar . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 147
13.6.1. Eliminar la clase . . . . . . . . . . . . . . . . . . . . . . . 147
13.6.2. Eliminar un componente . . . . . . . . . . . . . . . . . . . 148

ÍNDICE GENERAL V
14. Matrices 151

14.1. Introducción . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 151
www.editorialuc.es
14.2. Creación . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 151
14.2.1. Función matrix() . . . . . . . . . . . . . . . . . . . . . . 151
14.2.2. Función dim() . . . . . . . . . . . . . . . . . . . . . . . . 152
14.2.3. Funciones cbind() y rbind() . . . . . . . . . . . . . . 153
14.3. Manejo de una matriz . . . . . . . . . . . . . . . . . . . . . . . . 154
14.3.1. Poner y quitar nombres . . . . . . . . . . . . . . . . . . . 154
14.3.2. Acceder a sus elementos . . . . . . . . . . . . . . . . . . . 156
14.3.3. Eliminar una fila o una columna . . . . . . . . . . . . . . 156
14.3.4. Extraer una submatriz . . . . . . . . . . . . . . . . . . . . 157
14.3.5. Funciones exploradoras en matrices . . . . . . . . . . . . 157
14.4. Cálculos en una matriz . . . . . . . . . . . . . . . . . . . . . . . . 160
14.5. Operaciones con matrices . . . . . . . . . . . . . . . . . . . . . . 162
14.5.1. Operaciones matemáticas elementales . . . . . . . . . . . 163
14.5.2. Multiplicación de dos vectores . . . . . . . . . . . . . . . 164
14.5.3. Multiplicación de una matriz por un vector . . . . . . . . 165
14.5.4. Multiplicación de dos matrices . . . . . . . . . . . . . . . 166
14.5.5. Matriz inversa . . . . . . . . . . . . . . . . . . . . . . . . . 167
14.5.6. Sistemas de ecuaciones lineales . . . . . . . . . . . . . . . 168
15. Arrays 171

15.1. Creación . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 171
15.2. Operaciones con arrays . . . . . . . . . . . . . . . . . . . . . . . . 173
16. Data frames 175

16.1. Creación . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 175
16.2. Lectura . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 176
16.2.1. La función read.table() . . . . . . . . . . . . . . . . . 176
16.2.2. La función read.csv() . . . . . . . . . . . . . . . . . . . 179
16.2.3. Otras funciones de lectura . . . . . . . . . . . . . . . . . . 179
16.3. División de una base de datos (submuestras) . . . . . . . . . . . 181
16.4. Mezcla de bases de datos . . . . . . . . . . . . . . . . . . . . . . . 182
16.5. Caracterı́sticas de un data frame . . . . . . . . . . . . . . . . . . 182
16.5.1. Dimensiones . . . . . . . . . . . . . . . . . . . . . . . . . 183
16.5.2. Estructura . . . . . . . . . . . . . . . . . . . . . . . . . . . 183
16.5.3. Variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . 184
16.5.4. Registros . . . . . . . . . . . . . . . . . . . . . . . . . . . . 184
16.5.5. Otros atributos . . . . . . . . . . . . . . . . . . . . . . . . 184
16.6. Depuración de una BdD . . . . . . . . . . . . . . . . . . . . . . . 185
16.6.1. Ordenar una BdD . . . . . . . . . . . . . . . . . . . . . . . 185
16.6.2. Seleccionar casos . . . . . . . . . . . . . . . . . . . . . . . 186
16.6.3. Trabajar con columnas de una BdD . . . . . . . . . . . . . 187
16.6.4. Trabajar con filas de una BdD . . . . . . . . . . . . . . . . 187
16.6.5. Trabajar con los missing de una BdD . . . . . . . . . . . . 187
16.7. Resumiendo el contenido de una BdD . . . . . . . . . . . . . . . 187

VI ÍNDICE GENERAL
17. Tiempo en R 191

17.1. Clases . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 192
17.2. Exploración del tiempo actual . . . . . . . . . . . . . . . . . . . . 192
17.2.1. La función Sys.timezone() . . . . . . . . . . . . . . . 192
17.2.2. La función Sys.time() . . . . . . . . . . . . . . . . . . . 193
17.2.3. La función Sys.Date() . . . . . . . . . . . . . . . . . . . 193
17.2.4. La función date() . . . . . . . . . . . . . . . . . . . . . . 194
17.3. Conversión de cadenas de caracteres en fechas . . . . . . . . . . 194
17.3.1. La función as.Date() . . . . . . . . . . . . . . . . . . . 194
17.3.2. La función ISOdatetime() . . . . . . . . . . . . . . . . 196
17.4. Operaciones con fechas y horas . . . . . . . . . . . . . . . . . . . 196
17.4.1. Sumas y restas . . . . . . . . . . . . . . . . . . . . . . . . 196
17.4.2. La función difftime() . . . . . . . . . . . . . . . . . . . 196
17.4.3. Generación de secuencias . . . . . . . . . . . . . . . . . . 197
17.5. Uso de fechas en Bases de Datos . . . . . . . . . . . . . . . . . . 198
18. Fórmulas en R 201

18.1. Declaración . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 201
18.1.1. Sı́mbolos empleados en las fórmulas . . . . . . . . . . . . 201
18.2. Uso . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 202
18.2.1. Fórmulas en gráficos . . . . . . . . . . . . . . . . . . . . . 202
18.2.2. Fórmulas en modelos de regresión . . . . . . . . . . . . . 204
18.2.3. Fórmulas en determinadas funciones . . . . . . . . . . . 205
19. Entornos en R 207

19.1. Tipos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 208
19.1.1. El entorno global . . . . . . . . . . . . . . . . . . . . . . . 208
19.1.2. El entorno base . . . . . . . . . . . . . . . . . . . . . . . . 208
19.1.3. El entorno vacı́o . . . . . . . . . . . . . . . . . . . . . . . . 208
19.1.4. El entorno de trabajo . . . . . . . . . . . . . . . . . . . . . 208
19.2. Papel del entorno . . . . . . . . . . . . . . . . . . . . . . . . . . . 208
19.3. Otras funciones para manejar el entorno . . . . . . . . . . . . . . 210
19.3.1. Crear . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 210
19.3.2. Explorar . . . . . . . . . . . . . . . . . . . . . . . . . . . . 210
19.3.3. Borrar . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 211
19.3.4. Ubicar . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 211
III GRÁFICOS EN R 213

20. Gráficos tradicionales 215
20.1. Las tres regiones de un gráfico . . . . . . . . . . . . . . . . . . . . 216
20.1.1. Fijaciones de nivel alto . . . . . . . . . . . . . . . . . . . . 216
20.1.2. Fijaciones de nivel bajo . . . . . . . . . . . . . . . . . . . . 217
20.2. Caracterı́sticas de un gráfico . . . . . . . . . . . . . . . . . . . . . 218
20.2.1. Color . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 218
20.2.2. Lı́neas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 219

ÍNDICE GENERAL VII
20.2.3. Sı́mbolos . . . . . . . . . . . . . . . . . . . . . . . . . . . . 219

20.2.4. Figuras . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 220
www.editorialuc.es
20.2.5. Textos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 220
20.3. Funciones gráficas . . . . . . . . . . . . . . . . . . . . . . . . . . . 221
20.4. Funciones gráficas de alto nivel . . . . . . . . . . . . . . . . . . . 221
20.4.1. Funciones para una variable . . . . . . . . . . . . . . . . 221
20.4.2. Funciones para dos variables . . . . . . . . . . . . . . . . 226
20.4.3. Funciones para más de dos variables . . . . . . . . . . . . 228
20.5. Funciones gráficas de bajo nivel . . . . . . . . . . . . . . . . . . . 240
20.5.1. Puntos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 240
20.5.2. Lı́neas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 241
20.5.3. Ejes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 242
20.5.4. Texto . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 243
20.6. Funciones interactivas . . . . . . . . . . . . . . . . . . . . . . . . 244
20.6.1. Lectura de coordenadas . . . . . . . . . . . . . . . . . . . 244
20.6.2. Identificación de puntos . . . . . . . . . . . . . . . . . . . 244
20.7. Gráficos condicionales . . . . . . . . . . . . . . . . . . . . . . . . 244
20.8. Gráficos dinámicos . . . . . . . . . . . . . . . . . . . . . . . . . . 246
20.9. Matriz de correlaciones . . . . . . . . . . . . . . . . . . . . . . . . 246
20.10.Mapas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 249
20.11.Funciones y paquetes en este capı́tulo . . . . . . . . . . . . . . . 249
21. Gráficos Trellis 253

21.1. Uso básico . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 254
21.2. Gráficos de ejemplo . . . . . . . . . . . . . . . . . . . . . . . . . . 254
21.2.1. Histogramas . . . . . . . . . . . . . . . . . . . . . . . . . . 254
21.2.2. Gráficos de densidad . . . . . . . . . . . . . . . . . . . . . 255
21.2.3. Gráficos boxplot . . . . . . . . . . . . . . . . . . . . . . . 256
21.2.4. Gráficos violinplot . . . . . . . . . . . . . . . . . . . . . . 259
21.2.5. Gráficos de barras . . . . . . . . . . . . . . . . . . . . . . 259
21.2.6. Diagramas de puntos . . . . . . . . . . . . . . . . . . . . . 261
21.2.7. Scatter plots . . . . . . . . . . . . . . . . . . . . . . . . . . 262
21.2.8. Gráficos tridimensionales . . . . . . . . . . . . . . . . . . 264
21.2.9. Matriz de correlaciones . . . . . . . . . . . . . . . . . . . 266
21.2.10.Mapas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 268
22. Gráficos ggplot2 271

22.1. Estructura de los gráficos . . . . . . . . . . . . . . . . . . . . . . . 271
22.2. Gráficos de ejemplo . . . . . . . . . . . . . . . . . . . . . . . . . . 273
22.2.1. Nubes de puntos . . . . . . . . . . . . . . . . . . . . . . . 273
22.2.2. Histogramas y curvas de densidad . . . . . . . . . . . . . 277
22.2.3. Box plots . . . . . . . . . . . . . . . . . . . . . . . . . . . . 282
22.2.4. Curvas y otras funciones . . . . . . . . . . . . . . . . . . . 283
22.2.5. Gráfico de barras . . . . . . . . . . . . . . . . . . . . . . . 287
22.2.6. Matriz de correlaciones . . . . . . . . . . . . . . . . . . . 288
22.2.7. Mapas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 289

VIII ÍNDICE GENERAL
IV PROGRAMACIÓN 293
23. Scripts 295
23.1. Concepto . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 295
23.2. Manejo de scripts . . . . . . . . . . . . . . . . . . . . . . . . . . . 295
23.2.1. Escritura . . . . . . . . . . . . . . . . . . . . . . . . . . . . 296
23.2.2. Grabación . . . . . . . . . . . . . . . . . . . . . . . . . . . 298
23.2.3. Lectura . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 299
23.2.4. Ejecución del script . . . . . . . . . . . . . . . . . . . . . . 299
24. Programación de funciones 301

24.1. Componentes de una función . . . . . . . . . . . . . . . . . . . . 301
24.1.1. Argumentos . . . . . . . . . . . . . . . . . . . . . . . . . . 302
24.1.2. Cuerpo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 303
24.1.3. Entorno . . . . . . . . . . . . . . . . . . . . . . . . . . . . 303
24.2. Caracterı́sticas de las funciones . . . . . . . . . . . . . . . . . . . 305
24.2.1. Escribiendo una función . . . . . . . . . . . . . . . . . . . 305
24.2.2. Ámbito de una función . . . . . . . . . . . . . . . . . . . 308
24.3. Clases de funciones . . . . . . . . . . . . . . . . . . . . . . . . . . 309
25. Estructuras de control 315

25.1. Ejecución condicional . . . . . . . . . . . . . . . . . . . . . . . . . 316
25.1.1. if . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 316
25.1.2. if else . . . . . . . . . . . . . . . . . . . . . . . . . . . . 317
25.1.3. ifelse() . . . . . . . . . . . . . . . . . . . . . . . . . . . 320
25.1.4. ifelse() anidados . . . . . . . . . . . . . . . . . . . . . 321
25.2. Ejecución repetitiva . . . . . . . . . . . . . . . . . . . . . . . . . . 322
25.2.1. for . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 322
25.2.2. repeat . . . . . . . . . . . . . . . . . . . . . . . . . . . . 323
25.2.3. while . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 324
25.3. Funciones en este tema . . . . . . . . . . . . . . . . . . . . . . . . 325
26. Primeras funciones escritas por el usuario 327

26.1. Programando funciones triviales . . . . . . . . . . . . . . . . . . 327
26.1.1. Primera función: Fsaludos() . . . . . . . . . . . . . . . 327
26.1.2. Segunda función: Fmedia() . . . . . . . . . . . . . . . . 329
26.2. Programando funciones no tan triviales . . . . . . . . . . . . . . 330
26.2.1. Tercera función: Fdescrip basica() . . . . . . . . . . 330
26.2.2. Cuarta función: Ftabla diag() . . . . . . . . . . . . . . 332
26.2.3. Quinta función: Fazar() . . . . . . . . . . . . . . . . . . 333
27. Funciones de utilidad 337

27.1. Programando otras funciones con utilidad . . . . . . . . . . . . . 337
27.1.1. Estad. descriptiva de una variable numérica: Fed n() . 337
27.1.2. Normalidad de una variable: Fnormalidad() . . . . . 340
27.1.3. Histograma mejorado: Fh() . . . . . . . . . . . . . . . . 342
27.1.4. Calidad de una base de datos: Fcomplete cases() . . 344

ÍNDICE GENERAL IX
27.1.5. Pruebas diagnósticas: Fprueba diag() . . . . . . . . . 347

www.editorialuc.es
28. Depuración de errores 353
28.1. Depuración de errores . . . . . . . . . . . . . . . . . . . . . . . . 353
28.1.1. La función debug() . . . . . . . . . . . . . . . . . . . . . 353
28.1.2. La función traceback() . . . . . . . . . . . . . . . . . . 355
28.2. Depuración en el entorno de RStudio . . . . . . . . . . . . . . . . 355
29. Programación orientada a objetos 359

29.1. Concepto . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 359
29.2. Antecedentes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 359
29.3. Clases . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 361
29.4. Objetos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 361
29.5. Caracterı́sticas de la OOP . . . . . . . . . . . . . . . . . . . . . . 361
29.5.1. Ventajas de la OOP . . . . . . . . . . . . . . . . . . . . . . 361
29.6. Tipos de OOP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 361
29.6.1. Clase S3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . 362
29.6.2. Clase S4 . . . . . . . . . . . . . . . . . . . . . . . . . . . . 368
30. La función apply y similares 371

30.1. Introducción . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 371
30.2. Sobre arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 372
30.2.1. apply() . . . . . . . . . . . . . . . . . . . . . . . . . . . . 372
30.3. Sobre listas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 374
30.3.1. lapply() . . . . . . . . . . . . . . . . . . . . . . . . . . . 374
30.3.2. sapply() . . . . . . . . . . . . . . . . . . . . . . . . . . . 375
30.4. Sobre vectores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 377
30.4.1. tapply() . . . . . . . . . . . . . . . . . . . . . . . . . . . 377
30.4.2. split() . . . . . . . . . . . . . . . . . . . . . . . . . . . . 378
30.5. Sobre data frames . . . . . . . . . . . . . . . . . . . . . . . . . . . 379
30.5.1. by() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 379
30.5.2. aggregate() . . . . . . . . . . . . . . . . . . . . . . . . 380
30.6. Otras . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 381
30.6.1. mapply() . . . . . . . . . . . . . . . . . . . . . . . . . . . 381
30.6.2. vapply() . . . . . . . . . . . . . . . . . . . . . . . . . . . 381
30.6.3. eapply() . . . . . . . . . . . . . . . . . . . . . . . . . . . 382
30.6.4. outer() . . . . . . . . . . . . . . . . . . . . . . . . . . . . 383
30.6.5. sweep() . . . . . . . . . . . . . . . . . . . . . . . . . . . . 383
30.7. Funciones en este tema . . . . . . . . . . . . . . . . . . . . . . . . 384
31. Programación eficiente 387

31.1. Medición de la velocidad . . . . . . . . . . . . . . . . . . . . . . . 387
31.1.1. La función system.time() . . . . . . . . . . . . . . . . 387
31.1.2. La función microbenchmark() . . . . . . . . . . . . . . 388
31.2. Actuación sobre el lenguaje . . . . . . . . . . . . . . . . . . . . . 389
31.3. Actuación sobre la implementación . . . . . . . . . . . . . . . . . 389

www.editorialuc.es
Prólogo
Cada dı́a son mayores las exigencias metodológicas y es más evidente la ne-
cesidad que tenemos los investigadores de disponer, conocer y manejar herra-
mientas que faciliten el desarrollo de investigaciones de calidad y alto impacto.
Esta aseveración es muy válida cuando hablamos de herramientas estadı́sticas
que permitan analizar los datos de nuestras investigaciones y postular conclu-
siones que hagan avanzar el conocimiento médico y modificar nuestras actitu-
des ante la enfermedad y el sufrimiento que la circunda.
La realidad más frecuente en biomedicina nos muestra como el investiga-
dor tiene que compaginar en muchas ocasiones su curiosidad investigadora
con otras obligaciones que reducen el tiempo y la energı́a disponible para inte-
grar todas esas exigencias metodológicas que crecen continuamente en el mun-
do de la investigación de primera lı́nea.
Libros como este nos sirven de gran ayuda para situarnos en un nivel de
conocimiento adecuado de una de las herramientas estadı́sticas mas utilizadas
en la actualidad, seguramente debido a que es gratuita, a sus excelentes ca-
pacidades gráficas y también a que proporciona claras ventajas en el análisis
y manejo de grandes bases de datos. Esto último de gran trascendencia en la
actualidad, ya que tanto la investigación colaborativa como el desarrollo de in-
vestigaciones que generan ingentes bases de datos, nos hacen valorar mucho
el programa R y sus caracterı́sticas.
Se hace fácil, y yo dirı́a que casi ameno, navegar por los capı́tulos del libro,
seguramente, porque ya desde su conceptualización inicial, y claramente du-
rante el desarrollo y confección del mismo, el autor (Carlos) no ha perdido la
guı́a directriz para lo cual fue concebido: su utilidad práctica. Esto es de agra-
decer y representa un gran atractivo del libro. Su organización permite, de una
manera fácil, seleccionar la lectura especı́fica de aquellos capı́tulos pertinentes
para la situación de necesidad en la que nos encontremos, y esto hace que sea
de gran un beneficio. Los investigadores necesitamos, como he dicho ya an-
teriormente, ser grandes conocedores del método estadı́stico y también de los
programas disponibles para desarrollar esos análisis, pero también considero
que la mayorı́a de nosotros estamos ávidos de poder disponer de libros como
este, que faciliten nuestro trabajo investigador.
Con la intención de convertirse en un apoyo formativo para los profesiona-
les del ámbito de la salud surge este libro, y la sensación de ser realmente un
soporte importante para nosotros es la que prevalece cuando terminamos de
leer la obra.

XII ÍNDICE GENERAL
Toda investigación implica la recogida de datos, almacenamiento, depura-

ción y análisis estadı́stico de los mismos. El investigador debe tener soltura en
el manejo de la informática, para lo cual es fundamental conocer el programa
R, que se fundamenta en el lenguaje R que comenzó a desarrollarse hace dos
décadas.
El libro está dividido de manera acertada en cuatro partes fundamentales:
Una primera parte, dedicada al programa R y su entorno, se presenta en los
capı́tulos 2–6 con 19 ejemplos y 35 problemas. Aquı́ el lector se pondrá en con-
tacto con el programa R, obtención e instalación del mismo y del entorno de
programación RStudio. Aprenderá a manejar las distintas librerı́as existentes
y a utilizar R como una calculadora cientı́fica de alta calidad. También apren-
derá a encontrar ayuda para cualquier duda que le surja sobre R.
Una segunda parte, dedicada a conocer el lenguaje R constituye el grueso
de esta obra. Si alguien quiere dominar un lenguaje, debe aprender su sintaxis y
su gramática; por tanto, en los capı́tulos 7–19, con 176 ejemplos y 63 problemas,
el lector adquirirá un conocimiento básico sobre los distintos objetos de R y
cómo trabajar con ellos.
Una tercera parte, dedicada a los gráficos en R es tratada en los capı́tulos
20–22 con 62 ejemplos y 11 problemas. R destaca sobre otros programas es-
tadı́sticos por sus excedentes capacidades gráficas, que el lector aprenderá a
poner en práctica a lo largo de estos capı́tulos.
Una cuarta parte, dedicada a la programación en R, ocupa los capı́tulos 23–
31 con 87 ejemplos y 18 problemas. R dispone de un lenguaje de programación,
muy sencillo e intuitivo, que permite al investigador escribir sus propios pro-
gramas en caso de ser insuficientes las más de 4 000 funciones existentes en
la instalación base y las varias decenas de miles de funciones existentes en los
casi 9 000 paquetes que se pueden descargar.
Esta obra, con 77 tablas y 136 figuras, pretende ser, en todo momento, útil
para el investigador y eminentemente práctica, de ahı́ que se procura huir de
las demostraciones matemáticas rigurosas, aunque sı́ precisa de unos conoci-
mientos matemáticos a nivel de cálculo básico. Se acompaña de muchos ejem-
plos (344) y problemas (129) para que el lector vaya poniendo en práctica lo
aprendido.
¡Aprendan y disfruten!
Prof. Benedicto Crespo Facorro

Catedrático de Psiquiatrı́a, Universidad de Cantabria
Jefe de Sección HU Marqués de Valdecilla
Investigador IDIVAL, CIBERSAM.

www.editorialuc.es
Prefacio
Investigar implica descubrir algo. Las personas siempre están buscando ex-
plicaciones sobre lo que ven u observan. Ese desconocimiento sobre la realidad
de su entorno les hace preguntarse por su razón de ser; ante lo cual solo que-
dan dos posibles caminos a seguir: el camino fácil: aceptar una explicación ((sin
más)), porque lo dice un ser considerado superior o alguien con mayor expe-
riencia o alguien a quien se le atribuyen mayores conocimientos; o el camino
difı́cil, pero más gratificante: intentar buscar por sı́ mismos el porqué o la res-
puesta a la pregunta que se hacen sobre algo que les preocupa. Basados en
distintas pistas (en latı́n ((vestigium))) que observan, pueden ir hacia (en latı́n
((in))) la respuesta; ası́ surge la ((investigación)).
Los distintos profesionales de las Ciencias de la Salud (médicos, farmacéuti-
cos, enfermeras, biólogos, etc.), que trabajan en la compleja realidad que rodea
al ser humano y su entorno, constantemente se hacen muchas preguntas que
deben ser respondidas. Su respuesta se logra mediante la investigación. Por
tanto, todos estos profesionales están llamados a ser investigadores.
La investigación, uno de los principales motores del desarrollo de un paı́s,
solo tiene éxito cuando se hace adecuadamente, es decir, cuando sigue los pa-
sos del Método Cientı́fico, ya que si transcurre por un camino confundido, o
erróneo, no llegará a alcanzar el fin pretendido. Por tanto, los investigadores
necesitan formación en Metodologı́a de la Investigación.
Muchos profesionales no tienen tiempo para dedicarse en exclusiva a ad-
quirir esta formación; deben compaginarla con su trabajo diario. De ahı́ la ne-
cesidad de la existencia de ((cursos a distancia)) sobre este tema. Este libro sirve
como apoyo en esta actividad formativa, por lo que va dirigido a cualquier
persona del ámbito de la Ciencias de la Salud con una titulación de Grado.
En el capı́tulo 1 se hace una breve presentación del Método Cientı́fico para
enseñar al lector la importancia del método y de sus distintas fases, que deben
transcurrir secuencialmente y en el orden presentado. Se insiste en que la única
puerta de entrada es la Pregunta de Investigación, por tanto, si el investigador
quiere entrar en el mundo de la investigación, obligatoriamente debe dedicar
un tiempo a pensar y escribir una buena pregunta de investigación.
Toda investigación implica la recogida de datos, almacenamiento, depura-
ción y análisis estadı́stico de los mismos. Actualmente no se concibe la inves-
tigación sin el uso del ordenador; ya pasó la época en la que el investigador
trabajaba con lápiz y papel o con la ayuda de una calculadora. El investigador
debe tener soltura en el manejo de la informática, para lo cual es fundamental

XIV ÍNDICE GENERAL
conocer el programa R, que destaca por sus excelentes capacidades estadı́sti-

cas y gráficas. Este programa se fundamenta en el lenguaje R que comenzó a
desarrollarse hace dos décadas.
Se ha dividido el libro en cuatro partes fundamentales:
Una primera parte, dedicada al programa R y su entorno.Es primordial que
el investigador tenga correctamente instalado el programa R y las librerı́as (pa-
quetes) de apoyo. El manejo adecuado de todo ello, ası́ como de las ayudas y
gestión de los ficheros y gráficos se facilita enormemente con el entorno de
programación RStudio .
Una segunda parte, se dedica a conocer la sintaxis y la gramática de R.
Si alguien quiere manejar un lenguaje, previamente debe aprenderlo correc-
tamente. Este esfuerzo se ve facilitado con multitud de ejemplos y problemas
que le proporcionarán la soltura necesaria para manejar los diferentes objetos
de R.
Si en algo destaca R sobre otros programas estadı́sticos es por sus exce-
dentes capacidades gráficas. El investigador que quiera transmitir sus ideas y
hallazgos debe antes aprender a crear los gráficos adecuados. En esta tercera
parte del libro se presentan los tres sistemas gráficos disponibles actualmente:
grid, lattice y ggplot2. En ellos el investigador descubrirá un sinfı́n de posibili-
dades.
La cuarta parte del libro se dedica a la programación en R. Se presenta pau-
latinamente para que el lector no se agobie, ni se asuste. Aprenderá a progra-
mar muchas funciones según sus necesidades.
Los motivos que han permitido el desarrollo de esta obra es proporcionarle
una serie de herramientas que el investigador debe conocer para utilizar co-
rrectamente la estadı́stica. Actualmente ésta se lleva a cabo con ordenadores,
pero no pulsando una tecla y que estos hagan lo que quieran, sino que es el
investigador el que decide lo que debe hacer, para lo cual es necesario conocer,
además de la estadı́stica, el lenguaje R. Sirva este libro como introducción y
adéntrese en este mundo maravilloso.
Santander, 5 de noviembre de 2016


www.editorialuc.es
Capı́tulo 1
El método cientı́fico
1.1. Introducción
El hombre siempre ha querido dar una explicación a la realidad que le ro-

dea. En un principio creı́a que todo sucedı́a como efecto de otras fuerzas supe-
riores, pero cuando pasó de dar explicaciones mágicas, a dar explicaciones que
podı́a contrastar con la realidad, surgió la investigación.
La investigación, del latı́n ((in)) (en o hacia) y ((vestigium)) (huella, pista), pre-
tende aumentar el conocimiento siguiendo pistas o rastros, es decir, pretende
resolver algún problema o descubrir algo desconocido; por lo que la investi-
gación se ha convertido en la Fuente de la Ciencia. La investigación pretende
descubrir nuevos hallazgos, o declarar nuevos principios o leyes, o reinterpre-
tar los hechos y principios existentes. La investigación intenta, de una manera
organizada y sistemática, descubrir la verdad. En el campo de la medicina el
fin último de la investigación es mejorar la salud de las personas [1, 2].
Hoy dı́a la ciencia y sus aplicaciones cientı́ficas se han convertido en el prin-
cipal motor del desarrollo de los paı́ses. Los antiguos romanos decı́an ((scientia
potentia est)) y actualmente se dice ((El conocimiento es poder)) [3].
Antes de seguir avanzando hemos de delimitar qué es ((investigación)). Hay
muchas definiciones, una, por ejemplo, es la que aparece en el Diccionario de
la Real Academia de la Lengua Española ((Realizar actividades intelectuales y ex-
perimentales de modo sistemático con el propósito de aumentar los conocimientos sobre
una determinada materia)) [4]. Para algunos estadı́sticos la definición es más sen-
cilla, pues para ellos ((investigar es cruzar variables)). Para otros, la investigación
es cualquier actividad desarrollada de forma sistemática con el fin de ampliar
e innovar nuestro campo del conocimiento [5]. La investigación es un proceso
sistemático, organizado y objetivo destinado a responder una pregunta [6]. Es
decir, investigación es un proceso que utiliza el Método Cientı́fico.
El investigador, para descubrir nuevos hechos o ratificar otros conocidos,
necesita una herramienta de trabajo, un método regular, sistemático y ordena-
do que, cuando se fundamenta en conocimientos cientı́ficos, adquiere el califi-
cativo de método cientı́fico [7].
1
2 CAPÍTULO 1. EL MÉTODO CIENTÍFICO
1.2. El Método Cientı́fico

Método, derivado del griego ((µεθoδoς)), es el procedimiento que se sigue
en las ciencias para hallar la verdad y enseñarla [4].
Tales de Mileto (624-546 AC) rechazó las explicaciones mágicas, religiosas o
sobrenaturales para los fenómenos naturales; enseñaba que dichos fenómenos
se debı́an a causas naturales, que habı́a que buscar. Se considera a Aristóte-
les (384-322 AC) como el padre del método cientı́fico, ya que afirmaba que el
conocimiento cientı́fico podı́a lograrse mediante la inducción. Posteriormente
fueron los árabes, cuyo máximo exponente fue Alhazen o Ibn al-Haytham de
Basora (965–1039), los que introdujeron la cuantificación y la experimentación
en la adquisición del conocimiento.
Figura 1.1: Padres del Método Cientı́fico: en el lado izquierdo, Tales de Mileto; en el
centro, Aristóteles y a la derecha, Alhazen.
Actualmente se considera al método cientı́fico como el camino o estrate-

gia que sigue una investigación para obtener un conocimiento válido, desde
el punto de vista cientı́fico, para hallar la verdad y, por tanto, para enriquecer
el Cuerpo de Conocimientos Cientı́ficos, también llamado Estado Actual de la
Ciencia.
Está basado en los principios de falsabilidad y reproducibilidad, como se
verá más adelante.
1.2.1. Hacer ciencia

El conocimiento de la realidad consiste en un proceso continuo de cotejar
los datos disponibles y los obtenidos mediante la experimentación con las con-
secuencias que se deducen de la hipótesis previa [8].
Mediante un proceso inductivo se rechaza o se modifica la hipótesis previa
por otra nueva que enriquece el conocimiento. Los datos obtenidos en la ex-
perimentación son aspectos parciales de la realidad, que muchas veces están
acompañados de ((ruido)) que dificulta su comprensión; de ahı́ que el proceso
de aprendizaje en la investigación sea un camino circular que se retroalimenta
continuamente y que abarca tanto procesos inductivos como deductivos (Figu-
ra 1.2).
La ciencia comenzó con la conjunción intelectual de seis individuos: Copérni-
co, Brahe, Kepler, Galileo, Descartes y Newton [9] que desarrollaron las bases
del método cientı́fico como un proceso de aprendizaje dirigido, que se basa tan-
to en la inducción como en la deducción [8]. A partir de una hipótesis inicial
H1 se deducen unas consecuencias, que contrastadas con los datos disponibles
se induce una nueva hipótesis modificada H2 .

1.3. FUNDAMENTOS FILOSÓFICOS 3
www.editorialuc.es
Figura 1.2: Bucle de retroalimentación en el proceso de aprendizaje de la investigación,
modificado de Box et al 1978 [8]. El investigador observa la realidad a través de una
ventana imperfecta (tipo de estudio). Esto junto con datos conocidos le permite, me-
diante un proceso de inducción, aceptar su hipótesis previa, o modificarla y de nuevo
iniciar otro estudio mejor.
1.3. Fundamentos filosóficos

Los filósofos que han estudiado la metodologı́a del conocimiento se han
decantado en dos corrientes fundamentales:
1.3.1. Los inductistas

a) los inductistas, que a partir de distintas observaciones parciales ascien-
den al todo, es decir, que a partir de observaciones directas o indirectas de la
naturaleza formulan una hipótesis plausible, que posteriormente es contrasta-
da con la realidad para ser aceptada o rechazada; y si es aceptada, se formula
una ley que generaliza el conocimiento. El filósofo más representativo de esta
corriente, que ha imperado en las ciencias de la salud, fue David Hume (1711–
1776), que entre 1739 y 1748 publicó sus principales trabajos [10–12], en los que
venı́a a decir que no se puede conocer nada de la naturaleza con anterioridad
a la experimentación.
Como bien dice Chalmers (1939– ) para que desde los hechos observables
esté justificada la inferencia inductiva a leyes, se deberı́an satisfacer tres con-
diciones: (1) el número de enunciados observacionales que constituyen la base
de una generalización debe ser grande; (2) las observaciones se deben repetir
en una amplia variedad de condiciones y (3) ningún resultado observacional
aceptado debe entrar en contradicción con la ley derivada [13].

Figura 1.3: En la izquierda: David Hume (1711–1776), máximo representante de los

inductivas y a la derecha, Karl Popper (1902–1994), ((padre)) de los refutacionistas.
1.3.2. Los refutacionistas

La otra corriente filosófica es la refutación deductiva de Karl Popper, quien
cree que para que una hipótesis sea útil ha de predecir fenómenos observables
que puedan ser falseados, como se recoge en sus trabajos publicados entre 1935
y 1974 [14–19].
Una hipótesis pretende describir el comportamiento de algún aspecto de la
naturaleza; para que pueda pasar a formar parte de la ciencia debe ser falsable
y esto sucede cuando existe un enunciado observacional lógicamente posible
que es incompatible con la hipótesis, que en caso de ser verdadero la falsa. Por
tanto, una teorı́a será muy buena cuando haga afirmaciones muy amplias acer-
ca del mundo y que sean muy falibles, pero que resistan la falsación siempre
que la teorı́a se someta a pruebas. Siempre se han de preferir las teorı́as más
falsables, pero que no hayan sido falsadas [13].
Además han surgido otras corrientes filosóficas que intentan explicar el co-
nocimiento cientı́fico [20, 21]. c) la visión sociohistórica de Kuhn [22–29], en que
los nuevos paradigmas consensuados desplazan a los existentes hasta ese mo-
mento; d) Lakatos propone el consenso para lograr teorı́as más generales [30–
34]; e) por último, aunque en oposición a estas filosofı́as de consenso, está la
anarquı́a recomendada por Feyerabend [35–41].
1.4. Fases del Método Cientı́fico

Debido a que el Método Cientı́fico debe ser la herramienta básica y funda-
mental en la Investigación Cientı́fica, es importante que, además de conocer
sus caracterı́sticas, se conozcan todas y cada una de las fases que le componen
y que deben ser superadas para llevar a buen fin las investigaciones que se
emprendan (Figura 1.4).

1.4. FASES DEL MÉTODO CIENTÍFICO 5
www.editorialuc.es
Figura 1.4: El Método Cientı́fico y sus diferentes fases. Partiendo de una pregunta
no resuelta, el investigador formula una hipótesis, elige un diseño y realiza el estudio,
obtiene datos de calidad que analiza y llega a unas conclusiones que debe publicar.
1.4.1. Pregunta de investigación

Investigar es, pues, un proceso sistemático, organizado y objetivo destina-
do a responder una pregunta [42]. Pregunta que debe estar bien formulada, ser
factible de estudiarse y que debe aportar una contribución útil a los conoci-
mientos que ya se tienen sobre el tema [43].
La pregunta de investigación surge en el investigador que está preocupa-
do por cuestiones relacionadas con su actividad diaria, o con la revisión bi-
bliográfica continua sobre su especialidad (por esto es aconsejable leer con asi-
duidad al menos dos revistas de la especialidad).
Un acrónimo que define bien las caracterı́sticas de una buena pregunta de
investigación es ((FINER)), que en inglés significa ((muy buena)), es decir, que to-
da buena pregunta de investigación debe ser: Factible, Interesante, Novedosa,
Ética y Relevante [44].
Factible. La pregunta convertida en proyecto de investigación, ¿es posible rea-

lizarlo con las personas y medios materiales que se tienen al alcance? Hay
que tener en cuenta que se necesitarán unos recursos materiales (apara-
taje, financiación, apoyo institucional), capacidad organizativa y logı́sti-
ca más o menos importantes según los objetivos. Además también hay
que considerar el número de sujetos necesarios (((tamaño muestral))) y la
posibilidad de no colaboración o de abandono prematuro. Hay que con-
siderar todos los aspectos antes de decidir que es factible: validez de los
cuestionarios, control de calidad del aparataje que se utilizará, armoniza-
ción de las técnicas, extracción, recogida, almacenamiento y envı́o de las
muestras, validación de las técnicas de laboratorio, etc.

Interesante. Si la pregunta de investigación no es buena o no aporta nada al

conocimiento cientı́fico seguro que no es atractiva para el investigador y,
por lo tanto, no merece la pena desarrollarla. Esta cualidad de interesante
no tiene que verse solo desde el punto de vista del investigador, conviene
que este hable con otras personas para conocer su opinión.
Novedosa. La obligación del investigador es aportar conocimiento a la Cien-

cia. Si la pregunta ya está resuelta no tiene ningún sentido dedicar re-
cursos a algo ya conocido, si bien es cierto que siempre es interesante y
necesario replicar estudios realizados mejorando los posibles errores de
investigaciones previas.
Ética. Aunque puesta en cuarto lugar, por su importancia debiera ser la pri-
mera [45]. No se puede ni se debe responder ninguna pregunta de in-
vestigación que no sea éticamente correcta [46], por lo que siempre hay
que tener en mente unos principios éticos básicos: (1) Autonomı́a o respe-
to a las personas, ya que ellas deben decidir por sı́ mismas, por lo que
una vez informadas de todo lo que se va a hacer (consentimiento infor-
mado) decidirán libremente si participan o no, y aquı́ hay que proteger
a los grupos especialmente vulnerables (mujeres embarazadas, ancianos,
niños, presos, discapacitados, etc.); (2) Justicia, que exige que todos los
seres humanos sean tratados con consideración y respeto pues tienen los
mismos derechos, por lo que no se deben seleccionar aquellos más dis-
ponibles o en situación de dependencia y, además, si hay posibilidad de
que surja un daño o perjuicio en la investigación, deberán estar cubiertos
obligatoriamente por un seguro; (3) Beneficencia, procurando el bien de
los sujetos sometidos a investigación y no exponiéndoles a riesgos inne-
cesarios; algunos autores distinguen (4) No maleficencia, es decir no hacer
daño a los sujetos, lo que exige entre otras cosas, la idoneidad del equi-
po investigador y la adecuación de los medios y centros. Por todo esto,
una de las obligaciones de todo investigador es acatar los principios éti-
cos de la Declaración de Helsinki, que se puede consultar en su página
web correspondiente: http://www.wma.net/es/30publications/
10policies/b3/.
Relevante. Se refiere a la importancia que tendrán los resultados en cuanto a

los conocimientos cientı́ficos y sus repercusiones en la salud de las per-
sonas o como punto de partida para nuevas investigaciones.
1.4.2. Búsqueda bibliográfica

Esta fase, que es muy importante, con frecuencia es obviada por algunos
investigadores, lo que lleva a realizar investigaciones para responder a pre-
guntas ya resueltas, o mal formuladas, o a emprender algo ya hecho, con lo
que se atenta contra la economı́a (por hacer un gasto innecesario) y probable-
mente contra la ética (por someter a personas, o a animales, a procedimientos
molestos, o dolorosos, o con efectos secundarios no deseables) [47].

1.4.3. Hipótesis y objetivos

La palabra ((hipótesis)) (del griego υπoθεσις), según el diccionario de la Real
www.editorialuc.es
Academia de la Lengua Española, es una suposición de una cosa posible o im-
posible para sacar de ella una consecuencia. Hipótesis es suposición, en con-
traposición a ((tesis)) (del griego θεσις) que significa conclusión o proposición
que se mantiene con razonamientos [4].
En primer lugar conviene declarar la hipótesis base del estudio. La hipóte-
sis se formula como lo que se supone que ocurre. Más adelante el estudio se
encargará de demostrar si la hipótesis es verdadera o no.
En segundo lugar describir los objetivos del estudio. El diseño del estudio
implica entre otras cosas el formular correctamente la pregunta en unos térmi-
nos (objetivos) claramente expuestos, que deben ser mensurables, compatibles
entre sı́ y alcanzables.
1.4.4. Experimento
Una vez declarada la hipótesis y establecidos los objetivos, habrá que di-
señar un experimento, o un estudio, que deberá estar plasmado en un Proyecto
de Investigación y que se realizará según se describa en el Manual Operativo.
Diseño experimental.
El diseño debe ser el adecuado para responder correctamente a los objetivos
propuestos, por lo tanto habrá que diseñar un experimento o tipo estudio en el
que se medirán una serie de variables en determinados sujetos.
Tipos de estudios. Fundamentalmente existen: a) los estudios observaciona-
les en los que el investigador se limita a observar lo que sucede, y esto lo puede
hacer analizando al mismo tiempo la causa y el efecto (estudios transversales),
o partiendo de la enfermedad busca hacia atrás la causa (estudios de casos y
controles), o puede partir de la causa y ver, en el tiempo, el desarrollo de la
enfermedad (estudios de cohortes); y b) los ensayos clı́nicos en los que el in-
vestigador no es un observador, sino que interviene en la exposición. Además
existen otros diseños menos utilizados.
Sujetos de experimentación. Hay que elegir a los individuos que partici-
parán en el estudio [48]. Conviene definir claramente qué caracterı́sticas deben
cumplir los sujetos que participarán en el estudio (criterios de inclusión), y de
éstos cuáles deberán eliminarse por diferentes causas (criterios de exclusión).
Variables. Hay que describir qué se va a medir: (variables independientes,
dependientes y de confusión) y en cuántos individuos (tamaño de la muestra).
Proyecto de investigación.
El proyecto de investigación sirve para estructurar el pensamiento del gru-
po investigador, en el sentido de explicitar claramente las razones de la investi-
gación, la hipótesis subyacente, los objetivos propuestos y cómo se va a trabajar
para conseguir estos objetivos. Además sirve para solicitar la ayuda económi-
ca (beca FIS o de otro tipo) que se pretende conseguir para poder desarrollar
el proyecto, ya que hoy en dı́a es imposible desarrollar ningún proyecto de in-
vestigación sin ayuda económica; por eso esta fase es muy importante que sea
elaborada con el máximo cuidado.

Este tipo de ayudas, como las becas FIS, tienen unas condiciones de obliga-
do cumplimiento: se deberá enviar en las fechas señaladas en la convocatoria
anual (las becas FIS se publican en el BOE), deben seguir un modelo estructu-
rado (que proporciona el propio FIS) y hay que adjuntar el currı́culum vitae
del investigador principal y de cada uno de los investigadores colaboradores
incluidos en el proyecto. El proyecto de investigación también deberá presen-
tarse al Comité Ético de Investigación Clı́nica correspondiente.
Manual Operativo.
El manual operativo es una versión ampliada de la sección de métodos del

protocolo del estudio [44]. En él debe quedar escrito, pormenorizadamente,
cómo se va a realizar el estudio.
Un manual operativo es esencial cuando la investigación es realizada por
diversos investigadores, ya que ayuda a reducir la variabilidad aleatoria y los
cambios en las técnicas de medición a lo largo del tiempo.
El manual operativo debe incluir todos los instrumentos e informes utili-
zados en el estudio, con instrucciones sobre la forma de ponerse en contacto
con los individuos, cómo hacer las entrevistas, cómo rellenar y codificar los
formularios, cómo procesar las muestras y cómo analizar los datos.
1.4.5. Base de datos

Una base de datos es una colección de datos relacionados que está alma-
cenada de forma organizada [49]. De cada elemento sujeto a investigación se
registran diversas variables. Esto se debe hacer registrando una columna por
cada variable y una fila por cada individuo. Al finalizar la recogida de datos se
tiene una matriz f × c, donde f son filas (individuos) y c son columnas (varia-
bles), tal y como se presenta en la Tabla 1.1.
Tabla 1.1: Estructura de una Base de Datos de n individuos y K variables
Individuo Variable1 Variable2 ... VariableK

1 . . ... .
2 . . ... .
3 . . ... .
4 . . ... .
5 . . ... .
... ... ... ... ...
n . . ... .
Para pocas variables es posible utilizar una hoja de cálculo tipo Excel [50]
como base de datos, pero para investigaciones algo más complejas, o en las que
se quieran implementar diferentes mecanismos para evitar la introducción de
datos erróneos, es mucho más adecuado utilizar una base de datos tipo Access
[51], y para estudios de mucha más envergadura se utilizan bases de datos

relacionales que deben ser consultadas con un lenguaje estructurado llamado

SQL.
www.editorialuc.es
De las bases de datos de escritorio, Access probablemente sea la más com-
pleta, y en un único fichero se almacenan tablas, consultas, formularios, infor-
mes y módulos. Permite al investigador programar y crear sus propias bases
de datos [52], dotándolas de mecanismos lógicos que impidan la introducción
de datos erróneos, y por tanto facilita la calidad de la investigación. Una parte
importante de los recursos en investigación se consumen en la consecución de
un fichero datos de calidad a partir de los datos recogidos inicialmente a fin de
evitar el sı́ndrome ((GIGO)), es decir ((garbage in, garbage out)).
Otros investigadores introducen los datos directamente en el programa es-
tadı́stico, que suele tener una forma similar a una hoja de cálculo, por ejemplo
SPSS [53]. Y otros almacenan los datos en un simple fichero de texto (sepa-
rando las columnas mediante comas o tabuladores, o en una posición fija) que
después será leı́do por algún paquete estadı́stico.
1.4.6. Análisis estadı́stico

Previamente a la realización del estudio se debe reflejar claramente, en el
proyecto de investigación, cómo se va a analizar (cuestiones estadı́sticas); tam-
bién habrá que buscar los posibles errores en la investigación (criterios de validez
interna y externa) y habrá que preguntarse por los posibles sesgos.
Generalmente se comienza con un análisis estadı́stico descriptivo de cada
variable. Esto permite conocer las variables, su distribución y otras caracterı́sti-
cas, e incluso ayuda a la depuración de los datos. Las variables numéricas se
describen mediante la media y la desviación estándar (no el error estándar) si
siguen una distribución normal (comprobada con la prueba de Shapiro-Wilk)
o con la mediana y el rango intercuartı́lico si no la siguen. Las variables cuali-
tativas se describen mediante tablas de frecuencia, porcentajes y sus intervalos
de confianza calculados mediante el método recomendado de Wilson.
A continuación se realiza una estadı́stica bivariable para encontrar posibles
asociaciones. Si se trata de dos variables cualitativas se suele emplear la prueba
ji-cuadrado (χ2 ) o la prueba exacta de Fisher y la fuerza de la asociación me-
diante el cálculo de la odds ratio (OR) o del riesgo relativo (RR). Si se trata de
una variable cualitativa y otra numérica se utiliza la prueba t de Student con
la corrección de Welch o el ANOVA. Y si se trata de dos variables numéricas
se utiliza la prueba r de Pearson; si este coeficiente de correlación fuera signi-
ficativo se puede calcular la ecuación de una recta mediante la regresión lineal
simple. En caso de no cumplirse las condiciones de aplicación de estas pruebas
se emplearán sus correspondientes pruebas no paramétricas. Esta búsqueda de
relaciones entre variables no se hace ((a ver qué sale)) como si se fuera a pescar,
sino que las diferentes comparaciones de proporciones o de medias se explo-
ran de acuerdo con los objetivos del estudio, de lo contrario se encontrarán
asociaciones simplemente debidas al azar.
Y, por fin, en una fase posterior se realiza la estadı́stica multivariable (re-
gresión múltiple, regresión logı́stica, análisis de la supervivencia, regresión de
Cox, etc.) ya que, en general, un efecto no se debe a un único factor sino a
varios, y estas técnicas estadı́sticas permiten estudiarlos a la vez y ver la im-
portancia de cada uno de ellos teniendo controlados (ajustados) los demás.

Actualmente la informática permite cálculos rápidos y seguros, por lo que

el análisis estadı́stico no debe hacerse ya a mano o con una calculadora, inclu-
so aunque se trate de pocos casos. Hay muchı́simos paquetes estadı́sticos en
el mercado, unos comercializados (SAS, Minitab, Statgraphics, Stata, S-PLUS,
NCSS, SPSS, etc.) con licencias caras, que muchas veces se alejan de las posibi-
lidades del investigador. Afortunadamente existen otros paquetes estadı́sticos
gratuitos, algunos on-line y otros descargables. De entre estos últimos destaca
el programa R, que además de ser totalmente gratuito, sobrepasa en capacida-
des a cualquier otro programa, comercial o no, por lo que es deseable que todo
investigador se vaya introduciendo en el manejo de este programa.
La estadı́stica aplicada al método cientı́fico en ocasiones tiene consecuen-
cias negativas, como refleja Ioannidis [54] ((cuanto más pequeños son los estu-
dios, es menos probable que los hallazgos sean verdaderos)).
Conviene consultar con un estadı́stico para evitar errores [55–57], y no pen-
sar que, porque se tiene un excelente programa estadı́stico, el autor, por arte de
birlibirloque, pasa a ser un experto en estadı́stica, al igual que un médico por
tener el mejor bisturı́ del mercado no pasa a ser un experto neurocirujano. En
palabras de Douglas G. Altman ((What should we think about a doctor who uses the
wrong treatment, either wilfuly or through ignorance, or who uses the right treatment
wrongly (such as by giving the wrong dose of a drug)? Most people would agree that
such behaviour was unprofessional, arguably unethical, and certainly unacceptable.
What, then, should we think about researchers who use the wrong techniques (either
wilfully or in ignorance), use the right techniques wrongly, misinterpret their results,
report their results selectively, cite the literature selectively, and draw unjustified con-
clusions? We should be appalled. Yet numerous studies of the medical literature, in
both general and specialist journals, have shown that all of the above phenomena are
common. This is surely a scandal.)) [58].
1.4.7. Publicación
Una vez concluida la investigación hay que redactar un informe (publica-
ción) con el fin de evitar que otros investigadores dediquen su tiempo, esfuer-
zos y recursos en algo que ya está resuelto y que, por tanto, debe pasar a en-
grosar el Cuerpo de Conocimientos Cientı́ficos. Es importante [59] seguir las
guı́as SAMPL [60], CONSORT [61], TREND [62] y STROBE [63].
1.5. La necesidad de investigación

La investigación en cualquier campo es fundamental para el progreso de
un paı́s y en especial la realizada en el campo de las Ciencias de la Salud [64].
Muchas veces se ha puesto de manifiesto la importancia que tiene para cual-
quier nación el apoyo a la investigación. De hecho, el desarrollo integral de una
nación moderna implica el desarrollo de su ciencia, no sólo porque es necesa-
ria para una economı́a vanguardista del paı́s, sino también porque no puede
haber cultura moderna sin una vigorosa ciencia actualizada [65].
La investigación es una necesidad para el desarrollo de toda profesión.
También es fundamental para la obtención de datos basados en la evidencia,
sobre los que luego pueda basarse la planificación, la práctica y la implantación
de servicios útiles para la sociedad [66].

1.6. CARACTERÍSTICAS PARA SER UN BUEN INVESTIGADOR 11
La medicina actual es efectiva para prevenir y tratar muchas de las enfer-

medades que aquejan al ser humano. Su fundamento es el resultado de la in-
www.editorialuc.es
vestigación que ha desarrollado sobre problemas clı́nicos y de salud pública,
desarrollada a lo largo de la historia. Pero la mayorı́a de las investigaciones
tienen errores que podrı́an evitarse y otros aspectos que podrı́an mejorarse. De
ahı́ la necesidad de formarse en Metodologı́a de la Investigación [67].
1.6. Caracterı́sticas para ser un buen investigador

La investigación la realizan personas, no cualesquiera, sino aquellas dota-
das de unas caracterı́sticas especiales: son creativas, tenaces, dotadas de una
capacidad para detectar preguntas importantes y para diseñar planteamientos
ingeniosos para responder dichas preguntas [66], están alerta a nuevas ideas
y técnicas que les pueden interesar, conocen y estudian la literatura publicada
en su área de interés, acuden a congresos y reuniones cientı́ficas, mantienen
una actitud escéptica acerca de los beneficios de las nuevas investigaciones,
son crı́ticos, aplican las nuevas tecnologı́as y eligen un mentor adecuado [47].
Los buenos investigadores suelen tener una buena capacidad de compagi-
nar y mezclar los objetivos cientı́ficos y los clı́nicos, utilizan el sentido común
para razonar la pregunta, diseñar el estudio que la pueda responder y, sobre
todo, disfrutan con la investigación [68].
Figura 1.5: Francis Bacon.
Las principales caracterı́sticas del investigador ya fueron descritas por el

inglés Francis Bacon (1561–1626), padre del empirismo (Figura 1.5), cuando las
expuso en su obra Novum Organum [69] aplicándoselas a sı́ mismo: ((Deduzco
por propia experiencia que para nada estaba tan preparado como para el estudio de la
verdad, ya que tenı́a un espı́ritu sutil y lo bastante ágil para ver las semejanzas de las
cosas (requisito esencial) y, al mismo tiempo, suficientemente firme para establecer y

distinguir los matices que las diferencian; también habı́a sido dotado por la naturaleza
del deseo de investigar, paciencia para dudar, solidez en la meditación, lentitud para
afirmar, prontitud en la consideración de lo nuevo, esmero en la disposición y ordena-
miento de las cosas; soy, además, hombre que nunca me inclino hacia lo nuevo ni admiro
lo antiguo y que odio toda suerte de impostura. Por esto pensé que mi naturaleza poseı́a
una cierta familiaridad y relación con la verdad)).
Para investigar no se necesita un amplio conocimiento de técnicas expe-
rimentales, ni de procedimientos de laboratorio, ni de grandes conocimientos
estadı́sticos; se precisan unos conocimientos básicos, un lenguaje adecuado pa-
ra entenderse con los expertos en metodologı́a (estadı́sticos y epidemiólogos),
tiempo para pensar, sentido común e ilusión por la investigación [70].
El investigador, para descubrir nuevos hechos o ratificar otros conocidos,
necesita una herramienta de trabajo, un método regular sistemático y ordena-
do que, cuando se fundamenta en conocimientos cientı́ficos, adquiere el califi-
cativo de método cientı́fico [7].
Para el investigador novel elegir un buen mentor es fundamental [71–78],
aunque es un proceso difı́cil, tal y como afirman Hulley et al. [47].
En palabras textuales de estos autores:
((Nothing substitutes for experience in guiding the many judgments in-

volved in conceiving and fleshing in a research question. Therefore an es-
sential strategy for a new investigator is to apprentice herself to an expe-
rienced mentor who has the time and interest to work with her regularly.
A good mentor will be available for regular meetings and informal discus-
sions, encourage creative ideas, provide wisdom that comes from experien-
ce, help ensure protected time for research, open doors to networking and
funding opportunities, encourage the development of independent work,
and put the new investigator’s name first on grants and publications whe-
never possible. Sometimes it is desirable to have more than one mentor,
representing different disciplines. Good relationships of this sort can also
provide tangible resources that are needed—office space, access to clinical
populations, datasets and specimen banks, specialized laboratories, finan-
cial resources, and a research team. Choosing a mentor can be a difficult
process, and is perhaps the single most important decision a new investi-
gator makes)).
(Hulley, Cummings, Browner, Grady, and Newman)
1.7. Investigación de calidad

En el apartado de estadı́stica citamos literalmente a Douglas Altman, quien
puso de manifiesto en la última década del siglo pasado, en uno de los más im-
pactantes artı́culos publicados, que la investigación médica era de baja calidad.
Han transcurrido dos décadas y la situación no ha mejorado: estudios recien-
tes ponen de manifiesto que un alto porcentaje de los originales publicados en
revistas cientı́ficas de gran prestigio siguen presentando errores en el análisis
estadı́stico o en la interpretación de resultados, lo que repercute en la calidad,
validez y eficiencia de la investigación [79].
En un artı́culo publicado en la revista Statistics in Medicine, Douglas Alt-
man resume la situación con estas palabras: ((La razón principal de la gran canti-

1.7. INVESTIGACIÓN DE CALIDAD 13
Tabla 1.2: Some Research Practices that May Help Increase the Proportion of True
Research Findings [80].
www.editorialuc.es
Research Practices
• Investigación en colaboración a gran escala
• Adopción de una cultura de replicación de los estudios
• Registro (de los estudios, protocolos, códigos de análisis, bases de datos,
datos crudos y resultados)
• Compartir (datos, protocolos, materiales, software y otras herramien-
tas)
• Adopción de prácticas de reproducibilidad
• Containment of conflicted sponsors and authors
• Utilización de los métodos estadı́sticos más apropiados
• Estandarización de las definiciones y análisis
• Umbrales más rigurosos antes de declarar descubrimientos o éxitos
• Mejora de los estándares de diseño del estudio
• Mejora en la revisión por pares, en los informes y en la publicación
• Mayor entrenamiento cientı́fico en métodos y técnicas estadı́sticas
dad de errores estadı́sticos es que la mayorı́a de los análisis lo realizan personas con un
conocimiento inadecuado de los métodos estadı́sticos. Posteriormente son revisados por
personas que generalmente no tienen mayor conocimiento. Lamentablemente, muchas
investigaciones pueden beneficiar más a los investigadores que a los pacientes, especial-
mente cuando se llevan a cabo por una ridı́cula necesidad de carrera profesional)).
No conviene olvidar que más del 85 % de la investigación biomédica actual
es inútil [80–84] y a veces fraudulenta [85], que muchos investigadores no co-
nocen bien las técnicas estadı́sticas y que muchos revisores de revistas (incluso
prestigiosas) tampoco, por lo que es importante y urgente adoptar prácticas
que mejoren la calidad de la investigación, como las propuestas por J. P. A.
Ioannidis que se recogen en la Tabla 1.2.
PROBLEMAS
Problema 1. Nombre, al menos, seis caracterı́sticas que debe reunir un investigador.

Problema 2. Defina brevemente qué es una pregunta de investigación, qué es una
hipótesis y qué son los objetivos del estudio.
Problema 3. Describa brevemente los artı́culos 14–16 y 22–24 del Código de Hel-
sinki.
Problema 4. En relación con el papel que desempeña el investigador respecto a un
posible factor causal se pueden clasificar los estudios en dos grandes grupos, ¿cuáles
son?
Problema 5. ¿Cómo se debe referenciar la última versión del código de Helsinki?
Problema 6. Enumere seis caracterı́sticas que definen a un buen investigador.

Problema 7. ¿Cuál es la obra más importante y conocida de Kunt?

Problema 8. De las caracterı́sticas que definen una buena pregunta de investigación,
¿cuál es la más importante?
Problema 9. Para introducirse en el mundo de la investigación, ¿cuál es la tarea más
importante para el investigador novel?
Problema 10. ¿Qué porcentaje de toda la investigación que se realiza anualmente se
puede catalogar como inútil?
Problema 11. Busque, al menos, 3 referencias sobre el sı́ndrome GIGO.
Problema 12. Enumere las cinco caracterı́sticas de una buena pregunta de investi-
gación.

www.editorialuc.es
Parte I
EL PROGRAMA R

www.editorialuc.es
Capı́tulo 2
El programa R
2.1. Introducción
Desde hace unos cuarenta años (1976), Richard A. Becker, John M. Cham-
bers y Allan R. Wilks (Figura 2.1), un grupo de matemáticos estadı́sticos y
programadores inventaron el lenguaje S1 en los laboratorios AT&T Bell (EE.
UU.), que rápidamente evolucionó, debido a su gran aceptación, y se convir-
tió en la base del programa comercial S-PLUS, que comenzó a revolucionar el
análisis estadı́stico [86]. De su trabajo derivaron libros conocidos como ((brown
book)) [87], ((blue book)) [88], ((white book)) [89] y otros libros [90, 91].
Figura 2.1: Los ((padres)) del lenguaje ((S)) (de izquierda a derecha: Richard A. Decker,
John M. Chambers y Allan R. Wilks)
Mas tarde, en 1990, Ross Ihaka y Robert Gentleman (Figura 2.2), de la uni-
versidad de Auckland (Nueva Zelanda), comenzaron a trabajar en un proyec-
to relacionado, que publicaron en 1996 [92]; ellos decidieron crear una versión
que permitiera el acceso gratuito a cualquier usuario sin tener que invertir im-
portantes medios económicos de los que muchas veces carece y que llamaron
R [93], probablemente por las dos iniciales de sus nombres. Robert Gentelman
ha derivado hacia ((Bioconductor)), un subproyecto de R dedicado a la bioin-
formática [94].
1 en palabras de Chambers, ((S is a language for programming with data.))
17
18 CAPÍTULO 2. EL PROGRAMA R
Figura 2.2: Los ((padres)) del sistema ((R)) (a la izquierda Ross Ihaka y a la derecha
Robert Gentelman
Desde 1999 es mantenido por el R Development Core Team (el núcleo duro
de R), con un número de miembros que ha ido ampliándose desde los 7 inicia-
les hasta los 19 existentes actualmente. R puede ser descargado desde CRAN
(Comprehensive R Archive Network2 ). Además, los programadores que lo deseen
pueden incorporar sus propios programas enriqueciendo el sistema, de forma
que hoy en dı́a (24jul2016) disponemos de 8 815 paquetes o colecciones de fun-
ciones3 de gran utilidad en la epidemiologı́a, estadı́stica espacial, análisis de
genes, etc.
R es un lenguaje de programación de ordenadores dotado de un número
elevadı́simo de funciones matemáticas y estadı́sticas y, sobre todo, gráficas. El
hecho de estar basado en un lenguaje formal de ordenadores es lo que le da su
tremenda flexibilidad y aunque otros sistemas presentan interfaces más sim-
ples (menús desplegables), en el futuro esta amigabilidad se convierte en un
estorbo; y como bien dice Dalgaard [95], la flexibilidad de R es algo deseable4 .
R sirve para aprender estadı́stica, para enseñarla y para investigar nuevas
técnicas estadı́sticas. Un buen modelo de aprendizaje de estadı́stica es poder
separar las ideas y conceptos del estudiante de los datos estadı́sticos. Es desea-
ble que el estudiante solicite un análisis, examine el resultado y pueda modifi-
car lo solicitado. Este feedback de examinar los resultados intermedios fuerza al
estudiante a pensar en lo que está haciendo y en su utilidad [96].
Aunque inicialmente se diseñó para realizar computación cientı́fica y gráfi-
ca, hoy en dı́a se utiliza para casi todo (proyecciones en mapas, resolver su-
dokus, crear colores, trabajar con imágenes, resolver ecuaciones diferenciales,
procesar datos del genoma, etc.) Actualmente R se ha convertido en la ((lingua
franca)) de la computación estadı́stica [97].
El investigador sanitario debe aprender a utilizar R, porque supera a los
2 http://cran.r-project.org/
3 packages
en la terminologı́a de R.
4 ((Althoughelementary statistics is often presented as a collection of fixed procedures, analysis of mo-
derately complex data requires ad hoc statistical model building, which makes the added flexibility of R
highly desirable)) Palabras de este autor, uno de los componentes del núcleo duro de R, en su libro
((Introductory Statistics with R))

2.2. CARACTERÍSTICAS DEL SISTEMA R 19
grandes paquetes comerciales en muchas caracterı́sticas [98] y el dinero dedi-

cado a comprar SPSS [99] se puede dedicar a otros conceptos.
www.editorialuc.es
Según Gentelman, uno de los padres de R, hay muy buenas razones para
preferir R sobre otros lenguajes, fundamentalmente por sus buenos algoritmos
estadı́sticos, la alta calidad de sus rutinas numéricas, la excelente integración
con herramientas de visualización de datos, la reproducibilidad y, sobre todo,
su gran capacidad de interactuar con otros lenguajes y de crear nuevas estruc-
turas de datos [94, 100].
Actualmente, R es el programa estadı́stico más utilizado en el mundo acadé-
mico y tiene una documentación amplı́sima, por lo que representa una oportu-
nidad para el investigador novel.
2.2. Caracterı́sticas del sistema R

R posee unas caracterı́sticas (Tabla 2.1) que le hacen muy atractivo para
todos los usuarios [101–104], tanto para los ((no experimentados)) y que se en-
frentan por primera vez a él, como para los que ya tienen soltura en su manejo.
Tabla 2.1: Los principales puntos fuertes y caracterı́sticas de R.
Aspectos destacables de R
• Paquete ((Open source)). Gratis. Accesible libremente.
• Está basado en el lenguaje S.
• Es multiplataforma (Windows, Mac, Linux, iPhone, web, etc).
• Puede analizar cualquier tipo de datos.
• Es ampliable.
• Muchos de las funciones que ofrece en sus diferentes paquetes aún no
están disponibles en los programas estadı́sticos comerciales.
• Es un lenguaje fácil de aprender.
• Tiene muchas posibilidades y capacidad de manejo de datos.
• Gráficos de alta calidad y abundantes herramientas para su manejo.
• Colección de herramientas para análisis de datos y estadı́stica muy ex-
tensa y coherente.
• Adecuado para modelos estadı́sticos lineales y no-lineales.
• Gran utilidad en bioinformática, proteómica y áreas afines que tienen
sus propios requerimientos de biocomputación [94, 105–109].
• Poderosas herramientas para procesar datos de microarrays [110–112].
• Sistema utilizado por los estadı́sticos para probar nuevos modelos de
investigación de la propia estadı́stica.
• Permite a los usuarios noveles crear sus propias funciones, etc.
• Aceptado por la FDA para análisis de ensayos clı́nicos [113].
R es un sistema de programación orientado a objetos (OOP) [114] con gran-

des capacidades gráficas y dotado de múltiples herramientas para el análisis
estadı́stico. Es, pues, un entorno de computación estadı́stica que implementa
el lenguaje de programación S [115].

2.3. Obtención de R
Vaya a la página web http://cran.r-project.org/ donde encontrará
que puede descargarse el programa de instalación en Linux, (Mac) OS X y Win-
dows (Figura 2.3). Seleccione la opción deseada y tras unos cuantos segundos
habrá descargado el ejecutable correspondiente.
Figura 2.3: Página web de CRAN-R para descargar R.
2.4. Instalación de R y arranque del programa

Para cada sistema operativo la instalación es similar a la de otros programas
que haya instalado previamente.
2.4.1. Instalación de R
La instalación de R es muy sencilla y no presenta ninguna dificultad. Sim-
plemente vaya al directorio donde guardó el fichero que descargó, localı́celo
y pulse dos veces rápidamente con el ratón (botón izquierdo) y comenzará a
ejecutarse el programa de instalación.
2.4.2. Arranque de R
Una vez instalado, en el escritorio aparece su icono que al clicar en él arran-
ca el programa. En la pantalla aparece un texto que conviene leer (Figura 2.4), al
menos la primera vez, que le informa de la versión que está utilizando y le pro-
pone el uso de algunas funciones: license(), licence(), contributors(),
citation(), demo(), help(), help.start() que le aconsejo que explore.

2.4. INSTALACIÓN DE R Y ARRANQUE DEL PROGRAMA 21
www.editorialuc.es
Figura 2.4: Pantalla inicial tras arrancar R.
En primer lugar, borre la consola para dejarla en blanco (Figura 2.5). Esto se
hace desde el menú principal > Edit > Clear Console.
Figura 2.5: Pantalla ((en blanco)) preparada para empezar a trabajar con R.
Una vez llegados a este punto, ¡empiezan los problemas! para algunos usua-
rios: solo hay una pantalla en blanco con el prompt >, el indicador de dónde se
puede empezar a escribir algo. Los usuarios que vienen de otros programas con
menús desplegables, ventanas y más ventanas, echan en falta todas las pruebas
que pueden hacer con R. No se desespere, y comience a explorar algunas de
las funciones propuestas en la página inicial tras arrancar R.

> license()
This software is distributed under the terms of the GNU General

Public License, either Version 2, June 1991 or Version 3, June
2007. The terms of version 2 of the license are in a file called
COPYING which you should have received with this software and
which can be displayed by RShowDoc("COPYING").
Version 3 of the license can be displayed by RShowDoc("GPL-3").
Copies of both versions 2 and 3 of the license can be found

at https://www.R-project.org/Licenses/.
A small number of files (the API header files listed in

R_DOC_DIR/COPYRIGHTS) are distributed under the
LESSER GNU GENERAL PUBLIC LICENSE, version 2.1 or later.
This can be displayed by RShowDoc("LGPL-2.1"),
or obtained at the URI given.
Version 3 of the license can be displayed by RShowDoc("LGPL-3").
’Share and Enjoy.’
Si deseamos ver cómo deberemos citar R en nuestros trabajos [116]:

> citation()
To cite R in publications use:
R Core Team (2016). R: A language and environment for statistical

computing. R Foundation for Statistical Computing, Vienna, Austria.
URL https://www.R-project.org/.
A BibTeX entry for LaTeX users is
@Manual{,
title = {R: A Language and Environment for Statistical Computing},
author = {{R Core Team}},
organization = {R Foundation for Statistical Computing},
address = {Vienna, Austria},
year = {2016},
url = {https://www.R-project.org/},
}
We have invested a lot of time and effort in creating R, please cite it

when using it for data analysis. See also ‘citation("pkgname")’ for
citing R packages.
Para probar que se ha instalado correctamente teclee search() y la tecla

((INTRO)) para que R ejecute esta función que nos muestra qué hay en nuestro
entorno de trabajo, que como acabamos de instalar el programa únicamente
contendrá nueve objetos: .GlobalEnv en la primera posición, siete paquetes
(package:stats, ..., package:base) y Autoloads. No se preocupe si ahora
no sabe lo que esto significa, lo comprenderá conforme vaya transcurriendo su
aprendizaje de R.
> search() # contenido del entorno de trabajo
[1] ".GlobalEnv" "package:stats" "package:graphics"
[4] "package:grDevices" "package:utils" "package:datasets"
[7] "package:methods" "Autoloads" "package:base"

2.5. FUNCIONES Y PAQUETES EN ESTE CAPÍTULO 23
Cree ahora tres objetos5 tecleando lo siguiente:
www.editorialuc.es
> # Se crean los tres primeros objetos
> objeto1 <- date() # tipo fecha
> objeto2 <- ’Mi primer encuentro con R’ # tipo cadena
> objeto3 <- TRUE # tipo lógico
Para salir del programa [117] se puede cerrar clicando en el botón [X] de la
esquina superior derecha, o ejecutando la función quit() o la más sencilla e
idéntica q(). Ambas originan una ventana de diálogo para confirmar lo que
queremos hacer. Sin contesta afirmativamente, o teclea q(’yes’), el programa
antes de salir genera dos ficheros en su directorio de trabajo: (1) .Rhistory
con todo lo que haya tecleado en la consola de R y (2) .Rdata con todos los
objetos del área de trabajo.
Con la función save.image() podrı́a haber realizado lo mismo.
#---------------------------------------------------------------
save.image(file = ".RData", version = NULL, ascii = FALSE,
compress = !ascii, safe = TRUE)
#---------------------------------------------------------------
Si se almacenaron objetos de una sesión anterior, cuando arranque R en una

nueva sesión se recuperarán automáticamente en la memoria de trabajo. Para
comprobarlo arranque de nuevo y ejecute la función ls() que lista los objetos
que hay en el área de trabajo. Comprobará que lo primero que aparece en la
pantalla es [Previously saved workspace restored], indicando que
R ha recuperado los objetos que grabó al salir de la sesión anterior.
#---------------------------------------------------------------
ls(name, pos = -1L, envir = as.environment(pos),
all.names = FALSE, pattern, sorted = TRUE)
#---------------------------------------------------------------
> ls()
[1] "objeto1" "objeto2" "objeto3"
2.5. Funciones y paquetes en este capı́tulo

En este capı́tulo se han utilizado las funciones recogidas en las siguientes
tablas:
Tabla 2.2: Funciones de R utilizadas en este tema
Función Acción
Información sobre cómo citar
citation()
contributors() Autorı́a de un paquete
date() fecha actual
demo() Para ejecutar una demostración
Continúa en la página siguiente...
5 No se preocupe por no conocer aún qué es un objeto en R, en los próximos capı́tulos lo enten-
derá perfectamente.

Función Acción
hepl() Ayuda
help.start() Ayuda
licence() Licencia
license() Licencia
load() Lee el fichero ((Nombre.RData)) con datos graba-
dos previamente
ls() Listar objetos existentes en el área de trabajo
quit() Cerrar el programa
q() Cerrar el programa
save.image() Guardar los objetos del área de trabajo
search() Contenido en el entorno de trabajo (bases de datos,
listas o paquetes que se han sido conectados)
PROBLEMAS
Problema 1. Más que un problema, en este tema se le propone la siguiente tarea:
Instale en su ordenador personal de casa o del trabajo el programa R, ábrale (para
comprobar que está bien instalado) y ciérrele.
Problema 2. Compruebe que en su directorio de trabajo tiene dos ficheros: .Rhistory
y .Rdata.
Problema 3. Arranque R, vuelva a crear los tres objetos anteriores creados en esta
unidad y además creo otro objeto4 <- 4. Grábelo en un fichero con la función
save.image("MisDatos.RData"), salga de R y compruebe que en su directo-
rio de trabajo tiene un fichero llamado MisDatos.RData.
Problema 4. En una nueva sesión de R podrá leer estos datos almacenados en el
fichero MisDatos.RData con la función load("MisDatos.RData"). Hágalo
y compruebe que ahora tiene los cuatro objetos.
Problema 5. Compruebe que la fecha de su ordenador es la correcta.
Problema 6. ¿Qué versión de R tiene? (haga que aparezca en pantalla).

www.editorialuc.es
Capı́tulo 3
El entorno de programación
RStudio
3.1. El entorno de programación

Al igual que en otros lenguajes de programación, un entorno de progra-
mación o IDE (Integrated Development Environment) ayuda mucho en la tarea
de manejar R, un programa en el que el usuario necesita, a diferencia de otros
que emplean un sistema de menús desplegable (GUI, graphical user interface),
escribir órdenes y ejecutarlas en la lı́nea de comandos.
Un IDE debe reunir una serie de caracterı́sticas que permitan un adecuado
uso del lenguaje de programación:
Consola. Como R es un programa que interactúa con el usuario ejecutando las

órdenes que este solicita en la consola, un buen IDE tiene que tener una
consola que permita explorar diferentes comandos.
Editor de código fuente. Toda tarea de programación exige escribir un fichero

de órdenes (script) con un buen editor de código fuente que incluya, al
menos, una serie de caracterı́sticas que exigen los programadores:
Ayuda sensible según contexto.

Formateo automático del código fuente, control de paréntesis, so-
breiluminación de palabras clave.
Facilidad de navegación entre distintos ficheros de código fuente.
Compilación y ejecución amigable del código escrito.
Manejo de proyectos.
Herramientas de depuración de errores.
Integración con programas de escritura de informes
Explorador de objetos. Debe permitir conocer qué objetos se han creado, de

qué tipo y qué valores contiene.
Editor de objetos. Debe permitir inspeccionar el contenido de un objeto y po-

der editarle si fuera necesario.
25
26 CAPÍTULO 3. EL ENTORNO DE PROGRAMACIÓN RSTUDIO
Herramientas gráficas. Gran parte de la tarea estadı́stica consiste en crear gráfi-

cos, por lo que un buen IDE debe tener herramientas que permitan ma-
nejar los gráficos que el usuario crea.
Manejo de la ayuda. La ayuda debe estar integrada: hay tantı́simas funciones

que el usuario no puede recordar todas, por lo que un fácil acceso a toda
la documentación es importante.
Existen muchos IDE en el mercado: ESS, Eclipse, SciViews, JGR, TinnR, No-
tepad++, RGui. RStudio [118] es uno de los mejores [119], es gratis y se ac-
tualiza con frecuencia; por tanto, es el que vamos a utilizar en nuestro trabajo.
3.2. Instalación
3.2.1. Descarga
RStudio se descarga gratuitamente de su página web: http://www.rstudio.
org/download/. Para un usuario, hay que elegir la versión Desktop. Se des-
cargará un fichero que deberá ejecutar, aceptando las opciones que ofrece por
defecto y en unos minutos ya tiene RStudio en su ordenador.
3.2.2. Iniciando RStudio

Una vez instalado, pulsando en su icono entra en RStudio por primera
vez y aparece una pantalla dividida en tres ventanas: la mitad izquierda co-
rresponde a la ventana ((Console)) con la información inicial del sistema R, en
este caso se trata de la versión ((3.3.0 (2016-05-03) -- "Supposedly
Educational")), y la mitad derecha está dividida en dos ventanas, la del
((Environ-ment)) y la de los ((Plots)) (Figura 3.1).
Figura 3.1: Las tres ventanas del IDE cuando se entra por primera vez en RStudio .

3.2. INSTALACIÓN 27
3.2.3. Menú principal
www.editorialuc.es
El menú principal de RStudio ofrece muchas posibilidades (Figura 3.2)
Figura 3.2: Menú principal del IDE de RStudio .
Figura 3.3: Menú principal del IDE de RStudio con cuatro despliegues.
Figura 3.4: Menú principal del IDE de RStudio con cinco despliegues.

Es interesante que el lector explore el menú para irse haciendo una idea de
las importantes capacidades de RStudio (Figuras 3.3 y 3.4).
En cada uno de los menús desplegables encontrará opciones y también
combinaciones de teclas (((atajos))) que le permitirán sacar más provecho de to-
das las posibilidades que ofrece RStudio . También es importante que consulte
la página de ayuda https://support.rstudio.com/hc/en-us/categories/
200035113-Documentation de RStudio donde encontrará explicación a mu-
chas de las dudas que le puedan surgir mientras utiliza RStudio .
3.3. Las cuatro ventanas

Una vez que ha abierto un script (nuevo o antiguo), RStudio presentará siem-
pre cuatro ventanas (Figura 3.5) que vamos a ir explorando.
Figura 3.5: Las cuatro ventanas del IDE cuando se entra por segunda vez en
RStudio .
3.3.1. Ventana ((Source))

Esta ventana nos permite abrir distintos ficheros con el código fuente que
vamos tecleando, o que hemos tecleado anteriormente, y que podemos ejecutar
lı́nea a lı́nea, o un bloque de código o todo el fichero (Figura 3.6).
Para grabar el fichero con el código fuente se pulsa en el icono ((disco)).
Para ejecutar una lı́nea (siempre se ejecuta la lı́nea en la que está posicionado
el cursor) se pulsa ((Run)). Cuando se quiere ejecutar un bloque de código se
marca y se pulsa ((Run)). Para ejecutar todo el fichero se pulsa ((Source)).
Esta ventana tiene implementadas varias caracterı́sticas muy agradables
para el usuario:
Inserción automática de paréntesis emparejados: cada vez que se teclea

un paréntesis de apertura RStudio incluye el paréntesis de cierre para
que no se nos olvide. También empareja llaves de apertura-cierre y cor-
chetes de apertura-cierre.
Identación automática que facilita la lectura del código.

3.3. LAS CUATRO VENTANAS 29
Figura 3.6: Ventana ((Source)).
www.editorialuc.es
Completado automático (tab completion) de nombres de variables o de
funciones.
Información sobre los argumentos de las funciones.

Diferente color para palabras clave, comentarios, etc.
3.3.2. Ventana ((Console))

Aquı́ aparecen los resultados de la ejecución del código fuente. También
permite ejecutar funciones a modo de calculadora (Figura 3.7).
Figura 3.7: Ventana ((Console)).
A partir del prompt se puede empezar a teclear comandos u órdenes para

que se ejecuten. Si se pulsa la tecla ((intro)) sin que se haya completado la orden,

el cursor salta a la siguiente lı́nea y se posiciona después del signo + (continua-

tion prompt) para que se teclee lo que falta (puede ver estos dos tipos de prompt
en la Figura 3.7). Cuando hay un error, aparece información en rojo (muy útil
para los usuarios avanzados y muy desesperante y crı́ptica para los noveles).
No hay que desesperarse; conviene leerla con cuidado procurando entender lo
que dice, ya que informa sobre la causa de dicho error.
Esta ventana ((Console)) también tiene completado automático y ayuda de-
pendiendo del contexto:
En ocasiones interesa teclear algo similar a lo tecleado anteriormente. Serı́a

muy interesante poderlo ver, seleccionarlo y que pulsando ((intro)) se escribie-
se automáticamente. Esto se consigue con la combinación de teclas ((cmd)) y
((↑)) apareciendo una ventana con órdenes tecleadas anteriormente para que se
pueda seleccionar la que interese.
3.3.3. Ventana ((Environment))

Esta ventana permite ver todos los objetos que hay en memoria agrupa-
dos bajo tres epı́grafes (((Data)), ((Values)) y ((Functions))), sus caracterı́sticas e
incluso editarlos (Figura 3.8).
Figura 3.8: Ventana ((Environment)).
Un doble click en una función abre un visor con el código fuente en la ven-
tana ((Source)), como en la siguiente Figura 3.9.
Si el objeto es una base de datos (BdD) el browser la presenta en un formato
similar al de una hoja de cálculo para que pueda ser visualizada y editada
(Figura 3.10)

3.3.4. Ventana ((Plots))
www.editorialuc.es
Esta ventana es más compleja, ya que está formada por varias pestañas:
Figura 3.9: Browser del código de una función en la ventana ((Source)).
Figura 3.10: Browser de una BdD en la ventana ((Source)).

Files. Esta pestaña permite ver el árbol de directorios y los ficheros que tene-
mos en nuestro directorio de trabajo (Figura 3.11).
Figura 3.11: Pestaña ((Files)) de la ventana ((Plots)).
Desde el menú de esta pestaña se pueden crear nuevas carpetas, borrar

ficheros, renombrar ficheros, copiar, mover, etc. Se aconseja al lector que
explore todas las posibilidades.
Después de hacer cualquier cambio, es obligado pulsar en la flecha cir-
cular, que está en el extremo derecho del menú, para que los cambios se
reflejen en el árbol de directorios.
Plots. En esta ventana se presentan los gráficos que se van generando durante
el trabajo estadı́stico (Figura 3.12).
Figura 3.12: Pestaña ((Plots)) de la ventana ((Plots)).

En el submenú se observa, de izquierda a derecha, unas flechas que per-

miten al usuario navegar entre los diferentes plots generados. Puede ha-
www.editorialuc.es
cer un zoom y ası́ aparece en una ventana nueva el gráfico ((correcto)), ya
que el que aparece en la ventana ((Plots)) está adaptado a la configuración
de la ventana y la mayorı́a de las veces no es el adecuado. Se permiten
exportar los gráficos bajo diferentes formatos y, por supuesto, pulsando
es el pincel se puede borrar el gráfico.
Packages. En esta ventana se ven los paquetes que se tienen (Figura 3.13) ins-
talados, descargar e instalar más paquetes, actualizarlos, etc.
Figura 3.13: Pestaña ((Packages)) de la ventana ((Plots)).
Esta es una ventana que debe conocer muy bien el usuario de RStudio ,
ya que en muchas ocasiones tendrá que instalar o actualizar paquetes.
Help. RStudio integra su ayuda, junto con el completo sistema de ayuda de

R, en un sistema muy accesible (Figura 3.14).
Figura 3.14: Pestaña ((Help)) de la ventana ((Plots)).

3.4. Atajos
Facilita mucho la tarea de programación el uso de combinaciones de teclas
en vez del ratón (Tabla 3.1).
Tabla 3.1: Combinaciones de teclas que facilitan el trabajo en RStudio .
Rótulo1 Rótulo2
Ctrl + 1 Mueve el cursor a la ventana ((Source))
Ctrl + 2 Mueve el cursor a la ventana ((Console))
Ctrl + 3 Muestra el espacio de trabajo
Ctrl + 4 Muestra los datos
Ctrl + 5 Muestra el historial de comandos
Ctrl + 6 Muestra los ficheros
Ctrl + 7 Muestra los ((Plots))
Ctrl + 8 Muestra los paquetes
Ctrl + 9 Muestra la ayuda
Ctrl + L Borra y limpia ((Console))
3.5. Directorio de trabajo

Todos nuestros datos y ficheros de órdenes (scripts) relacionados con un
asunto determinado deben estar colocados en un directorio especı́fico, llamado
((directorio de trabajo)), que debe ser conocido por RStudio y por R.
Con RStudio hay varias maneras de definir dicho directorio (que es una
de las principales fuentes de error de los principiantes):
Mediante el menú: Session > Set Working Directory > Choose Direc-
tory y ası́ aparece una ventana donde podemos seleccionar con el ratón
el directorio (carpeta o subcarpeta) de trabajo (Figura 3.15).
Figura 3.15: Seleccionar el directorio de trabajo.
Arrancando un fichero scrip con RStudio .

3.5. DIRECTORIO DE TRABAJO 35
Creando un proyecto. RStudio se posiciona en el proyecto (aparece su

nombre en a la derecha del menú).
www.editorialuc.es
En la ventana ((Plots)), pestaña ((Files)), se selecciona en el árbol de direc-
torios, submenú ((More)), elegir ((Set As Working Directory)).
PROBLEMAS
Problema 1. Cree un directorio de trabajo en la carpeta ((Mis documentos)) con el
nombre ((Curso R)).
Problema 2. Abra RStudio y cree un fichero de código fuente ((Codigo fuente 1.R)).
Escriba unas lı́neas de comentario de cabecera de fichero. Escriba date(), ¿la fecha
que aparece en la ventana de la consola es la actual? Grabe este fichero de código.
Problema 3. Compruebe si aparece el fichero en la pestaña ((Files)) de la cuarta ven-
tana de RStudio .
Problema 4. Cree un proyecto nuevo llamado ((Curso R)).

www.editorialuc.es
Capı́tulo 4
Librerı́as en R
Aunque R dispone de más de 4000 funciones incorporadas en su instala-

ción base, el alumno debe conocer cómo buscar, instalar y usar alguno de los
paquetes que pueda necesitar, en especial se incidirá en los que más utilidad
tienen desde el punto de vista epidemiológico y sanitario.
Con R vienen una serie de paquetes que se pueden ver con la función
search(). Esta nos presenta en primer lugar el área de trabajo global, des-
pués las bases de datos que tenemos en memoria y finalmente los paquetes del
sistema R instalados.
> search()
[1] ".GlobalEnv" "tools:rstudio" "package:stats"
[4] "package:graphics" "package:grDevices" "package:utils"
[7] "package:datasets" "package:methods" "Autoloads"
[10] "package:base"
Con el sistema R se pueden realizar la mayorı́a de los cálculos estadı́sticos

que precisemos, pero siempre uno encuentra la necesidad de algo más y, o
lo programa uno mismo o instala un paquete que ya tenga programada esa
necesidad que tenemos. Hay varios miles de paquetes, lo que indica que otros
han sentido esa necesidad de programar lo que no existı́a. !Aprovechemos su
trabajo!.
4.1. Paquetes instalados

Cuando se instala R se instalan una serie de paquetes básicos (necesarios
para que R funcione) y otros recomendados (aportan funciones de uso fre-
cuente); unos y otros pueden verse ejecutando la función library() (Tabla
4.1):
También, con RStudio podemos ver esto mismo, pues él lleva un perfecto
control de los paquetes instalados en nuestro ordenador; por tanto, pulsando
la pestaña ((Packages)) vemos algo parecido (Figura 4.1).
37
38 CAPÍTULO 4. LIBRERÍAS EN R
Tabla 4.1: Paquetes instalados (en negrita los paquetes básicos y el resto son los reco-
mendados).
# Package Explanation
1 base The R Base Package
2 bitops Bitwise Operations
3 boot Bootstrap Functions (Originally by Angelo Canty for
S)
4 caTools Tools: moving window statistics, GIF, Base64, ROC
AUC, etc.
5 class Functions for Classification
6 cluster ”Finding Groups in Data”: Cluster Analysis Extended
Rousseeuw et al.
7 codetools Code Analysis Tools for R
9 compiler The R Compiler Package
10 datasets The R Datasets Package
11 foreign Read Data Stored by Minitab, S, SAS, SPSS, Stata, Sys-
tat, Weka, ...
12 dBase
13 graphics The R Graphics Package
14 grDevices The R Graphics Devices and Support for Colours
and Fonts
15 grid The Grid Graphics Package
16 gtools Various R Programming Tools
17 KernSmooth Functions for Kernel Smoothing Supporting Wand &
Jones (1995)
18 lattice Trellis Graphics for R
19 MASS Support Functions and Datasets for Venables and Ri-
pley’s MASS
20 Matrix Sparse and Dense Matrix Classes and Methods
21 methods Formal Methods and Classes
22 mgcv Mixed GAM Computation Vehicle with
GCV/AIC/REML Smoothness Estimation
23 nlme Linear and Nonlinear Mixed Effects Models
24 nnet Feed-Forward Neural Networks and Multinomial
Log-Linear Models
25 parallel Support for Parallel computation in R
26 rpart Recursive Partitioning and Regression Trees
27 spatial Functions for Kriging and Point Pattern Analysis
28 splines Regression Spline Functions and Classes
29 stats The R Stats Package
30 stats4 Statistical Functions using S4 Classes
31 survival Survival Analysis
32 tcltk Tcl/Tk Interface
33 tools Tools for Package Development
34 utils The R Utils Package

4.2. INSTALACIÓN DE UN PAQUETE 39
www.editorialuc.es
Figura 4.1: Paquetes instalados.
4.2. Instalación de un paquete

En RStudio instalar un paquete es muy fácil. Pinche en la pestaña ((Install
Packages)), aparecerá una ventana (Figura 4.2) en la que debe seleccionar el pa-
quete o los paquetes que quiera instalar. Le a consejo que instale, de momento,
Hmisc y car.
Figura 4.2: Seleccionar paquete.
4.3. Actualización de un paquete

De vez en cuando hay que actualizar los paquetes que tenemos instala-
dos en el ordenador, porque sus autores los van mejorando continuamente (!R
está vivo!) y conviene que tengamos la última versión.

Podemos explorar lo referente al estado de los paquetes con la función

packageStatus(): nos informa cuántos paquetes no tenemos actualizados
y cuantos tenemos instalados y cuántos aún no instalados.
4.4. Contenido de un paquete

Los paquetes contienen funciones y la mayorı́a de ellos también contienen
bases de datos (datasets) muy interesantes. Estas últimas se exploran con la fun-
ción data(). Ejecutando esta función aparece en una ventana todos los datasets
de los paquetes instalados en el ordenador. Si pasamos el paquete que que-
ramos explorar como argumento (por ejemplo, data(package=’rpart’))
sólo aparecen los de dicho paquete.
4.4.1. Cabecera de un paquete

La cabecera de un paquete, que contiene información sobre el contenidos
del mismo, se explora con la función packageDescription().
#---------------------------------------------------------------
packageDescription(pkg, lib.loc = NULL, fields = NULL,
drop = TRUE, encoding = "")
#---------------------------------------------------------------
Ejemplo 4.1. ¿Qué contiene la cabecera del paquete Hmisc?
> packageDescription(’Hmisc’)
Package: Hmisc
Version: 3.17-4
Date: 2016-05-02
Title: Harrell Miscellaneous
Author: Frank E Harrell Jr <f.harrell@vanderbilt.edu>,
with contributions from Charles Dupont and many
others.
Maintainer: Frank E Harrell Jr <f.harrell@vanderbilt.edu>
Depends: lattice, survival (>= 2.37-6), Formula, ggplot2
(>= 2.0)
Imports: methods, latticeExtra, cluster, rpart, nnet,
acepack, foreign, gtable, grid, gridExtra,
data.table
Suggests: chron, rms, mice, tables, knitr, ff, ffbase,
htmltools
Description: Contains many functions useful for data
analysis, high-level graphics, utility operations,
functions for computing sample size and power,
importing and annotating datasets, imputing missing
values, advanced table making, variable clustering,
character string manipulation, conversion of R
objects to LaTeX code, and recoding variables.
License: GPL (>= 2)
LazyLoad: Yes

4.5. PAQUETES RECOMENDADOS 41
URL: http://biostat.mc.vanderbilt.edu/Hmisc,
https://github.com/harrelfe/Hmisc
www.editorialuc.es
NeedsCompilation: yes
Packaged: 2016-05-02 14:10:51 UTC; harrelfe
Repository: CRAN
Date/Publication: 2016-05-02 17:28:19
Built: R 3.3.0; x86_64-apple-darwin13.4.0; 2016-05-05
16:21:13 UTC; unix
-- File: /Library/Frameworks/R.framework/Versions/3.3/Resources/l
ibrary/Hmisc/Meta/package.rds
4.4.2. ((Datasets)) de un paquete

Las BdD contenidas en un paquete se exploran con la función data(), pa-
sando como argumento package = "nombre".
#---------------------------------------------------------------
data(..., list = character(0), package = NULL, lib.loc = NULL,
verbose = getOption("verbose"), envir = .GlobalEnv)
#---------------------------------------------------------------
Ejemplo 4.2. ¿Qué datasets contiene el paquete Hmisc?
> data(package=’Hmisc’)
no data sets found
4.4.3. Contenido de todo el paquete

El contenido de todo el paquete se explora con la función help(), pasando
como argumento package = "nombre".
#---------------------------------------------------------------
help(topic, package = NULL, lib.loc = NULL,
verbose = getOption("verbose"),
try.all.packages = getOption("help.try.all.packages"),
help_type = getOption("help_type"))
#---------------------------------------------------------------
Ejemplo 4.3. ¿Cuál es el contenido del paquete UsingR?

Tecleando help() y como argumento package = ‘UsingR’).
4.5. Paquetes recomendados

A lo largo de este libro se recomiendan una serie de librerı́as que deberá ins-
talar en su ordenador.
4.5.1. De tipo general

Hay una serie de paquetes con funciones muy útiles.

Paquetes generales. Hay una serie de paquetes con muchas funciones de

gran utilidad en el manejo de datos y análisis estadı́stico de los mismos: car
[120], Hmisc [121], UsingR [122], MASS [102], vcd [123], DescTools [124],
DAAG [125],.
Paquetes especializados. Otros paquetes especializados que también uti-
lizaremos son los siguientes: nortest [126], binom y binomSamSize [127],
binGroup [128], asbio [129], pROC [130], prettyR [131].
4.5.2. De tipo epidemiológico

Los paquetes recomendados son los siguientes:
Epi. Se trata de un paquete con funciones para análisis estadı́stico epide-
miológico [132]. Tiene algunas funciones muy interesantes como por ejemplo
ci.pd() que calcula el IC-95 % de la diferencia de dos proporciones indepen-
dientes por el método recomendado de Newcombe [133]. También tiene otras
funciones que nos serán de gran utilidad: twoby2() para el análisis de tablas
2x2, clogistic() para la regresión logı́stica condicional y ROC() para curvas
ROC de pruebas diagnósticas.
epiR. Este paquete [134] también tiene interesantes funciones para el análi-
sis epidemiológico.
epibasix. Este paquete desarrollado por Rotondi [135] contiene herra-
mientas básicas para el análisis epidemiológico.
epicalc. Virasakdi Chongsuvivatwong, un epidemiólogo de la Universi-
dad Prı́ncipe de Songkla de Tailandia ha desarrollado este interesante paque-
te [136] que sirve de base de curso a distancia ((Analysis of epidemiological data
using R and Epicalc)) [137] y que usaremos mucho en este curso.
epinet. Este paquete contiene funciones para simular epidemias [138].
epitools. En la Universidad de Berkeley, Tomás Aragón [139] ha desarro-
llado este paquete con una interesante colección de funciones para el análisis
epidemiológoco.
4.6. Task Views

Conforme han ido aumentando los paquetes disponibles en CRAN, cada
vez le resulta más difı́cil al usuario encontrar qué paquete contiene las fun-
ciones que necesita. El equipo de desarrollo de R en su página web https:
//cran.r-project.org presenta los diferentes visores (Figura 4.3 y 4.4).
4.7. Funciones en este capı́tulo

En este capı́tulo se han utilizado las funciones recogidas en la siguiente
Tabla:

4.7. FUNCIONES EN ESTE CAPÍTULO 43
Tabla 4.2: Funciones de R utilizadas en este capı́tulo
www.editorialuc.es
Función Acción
available.packages() Lista de todos los paquetes disponibles
ci.pd() Intervalo de confianza de la diferencia de dos
prop. indep.
clogistic() Regresión logı́stica condicional
data() datasets existentes
help() Ayuda y contenido de paquetes
install.packages() Instalar un paquete
installed.packages() Paquetes instalados
library() Paquetes existentes
packageDescription() Descripción del contenido de un paquete
packageStatus() Información sobre paquetes instalados y en
repositorios
ROC() Curvas ROC
search() Paquetes y datasets en el entorno de trabajo
twoby2() Análisis epidemiológico de tablas 2x2
update.packages() Actualizar paquetes
PROBLEMAS
Problema 1. ¿Cuántos datasets contiene la librerı́a MASS?
Problema 2. ¿En qué paquete está la función pyramid()?
Problema 3. ¿Para qué sirve la función followup.plot()?
Problema 4. Instale el paquete epicalc.
Problema 5. ¿Cuántos datasets hay en el paquete epicalc?
Problema 6. ¿En qué paquete está la función DOTplot()?
Problema 7. ¿Cuántos paquetes tiene instalados en su ordenador?
Problema 8. ¿Cuántos paquetes más podrı́a instalar en su ordenador? (Nota: De-
pendiendo de los instalados, la respuesta de cada uno puede ser diferente)
Problema 9. ¿Quién mantiene el paquete MASS? ¿Quién es el autor del paquete
ggplot2?

Figura 4.3: Task Views disponibles en CRAN.
Figura 4.4: Task Views de Clı́nicalTrials (se presenta las primeras filas...).

www.editorialuc.es
Capı́tulo 5
R calculadora cientı́fica
5.1. Introducción
Utilizar R como una calculadora solo tiene utilidad en contadas ocasiones,
por ejemplo, cuando se necesita realizar un cálculo rápido sin tener que cargar
un fichero de órdenes (script). En ese caso se utilizarán algunas de las múltiples
funciones matemáticas incorporadas en el sistema R. Ya pasó la época en que
la estadı́stica se hacı́a ayudados de una calculadora cientı́fica (Figura 5.1).
Figura 5.1: Calculadora cientı́fica HP-S21 (1989).
5.2. Funciones básicas

Las funciones básicas necesitan que dos valores están relacionados con un
operador (Tabla 5.1). Siempre siguen la forma reflejada en la ecuación (5.1), que
relaciona los dos valores (a y b) con un operador:
a OP ERADOR b (5.1)
16
Ejemplo 5.1. Calcular: 1 + 13, 16 − 7, 14,0056 × 3,25, 2 y 73 .
45
46 CAPÍTULO 5. R CALCULADORA CIENTÍFICA
Tabla 5.1: Operadores matemáticos básicos
Operador Función
+ Suma
− Resta
∗ Multiplicación
/ División
ˆ Potenciación
%% Módulo o resto de una división
%/ % Cociente entero de una división
> 1 + 13 # suma
[1] 14
> 16 - 7 # resta
[1] 9
> 14.0056 * 3.25 # multiplicación
[1] 45.5182
> 16 / 2 # división
[1] 8
> 7 ˆ 3 # potencia
[1] 343
Ejemplo 5.2. Calcule el IMC de un sujeto que pesa 78 kg y mide 173 cm.
Como el IMC es el cociente entre el peso (en kg) y el cuadrado de la talla
(en m), se teclean estos y se obtiene que el IMC es 26.06168 kg · m−2 .
> 78 / 1.73 ˆ 2 # potencia y división

[1] 26.06168
Recordará que dividendo (D) partido por el divisor (d) es igual al cociente
(C) más el resto (R):
D
=C +R (5.2)
d
en R, el cociente (parte entera de la división) es C = D %/ % d y el resto
(módulo) es R = D % % d.
> 11 / 4 # división
[1] 2.75
> 11 %/% 4 # cociente (parte entera)
[1] 2
> 11 %% 4 # resto (módulo)
[1] 3
El cálculo del módulo tiene utilidad para saber si un número es par (módulo
0 al dividir el número por dos) o impar (módulo 1 al dividir por 2); también
para conocer si un número x es múltiplo de otro y, en cuyo caso el módulo
valdrá 0.
Ejemplo 5.3. ¿Es 54967 múltiplo de 11?

5.3. FUNCIONES AVANZADAS 47
> 54967 %% 11 # módulo

[1] 0
www.editorialuc.es
Sı́, puesto que el módulo al dividir 54967 entre 11 es 0.
Ejemplo 5.4. La clasificación de Berlı́n de la hipoxemia (2012) estableció tres

categorı́as en base al cociente P aO2 /F iO2 : severa (min,100], moderada (100,
200] y leve (200, 300]. Recientemente se ha publicado un trabajo [140] en el
que demuestran que el cociente en el dı́a 1 respecto del cociente en el dı́a 0
tiene mejor valor predictivo en la mortalidad a los 30 dı́as de un sı́ndrome de
distrés respiratorio agudo. Clasifique a un sujeto con P aO2 = 60 y F iO2 =
21 %.
> 60/.21 # hipoxemia leve

[1] 285.7143
5.3. Funciones avanzadas

Las funciones avanzadas aplican una función a un valor, tal y como se re-
presenta en la ecuación (5.3). La función consta de un nombre de la función, un
paréntesis de apertura, otro de cierre y entre ellos uno o dos valores llamados
((argumentos de la función)).
F U N CION (a, b) (5.3)

Entre estas funciones podemos considerar las de redondeo, las matemáticas
de tipo general o las más especializadas como son las trigonométricas y las
hiperbólicas.
5.3.1. De redondeo
Las funciones de redondeo se utilizan para quitar, total o parcialmente, los
decimales. Quedan recogidas en la Tabla 5.2.
Tabla 5.2: Funciones de redondeo

Operador Función
ceiling(a) Menor entero mayor que a
floor(a) Mayor entero menor que a
round(a, d) Redondea a con d decimales
signif(a, d) Presenta a con d dı́gitos en notación cientı́fica
trunc(a) Elimina los decimales de (a) hacia 0
El redondeo puede ser hacia el menor entero superior con ceiling(), ha-
cia el mayor entero inferior con floor(), ir eliminando decimales parcialmen-
te con round() o totalmente con trunc(). También se puede dejar un núme-
ro de cifras significativas con signif(). La que más utilizaremos, sin ninguna
duda, será la de redondeo.

Ejemplo 5.5. Dado un resultado x = 7,6459871, se pide: a) redondear x a

tres decimales, b) calcular el menor entero superior a x, c) calcular el mayor
entero menor que x, d) eliminar todos los decimales de x y e) presentar x con
dos cifras significativas.
> x <- 7.6459871
> round(x, 3)
[1] 7.646
> ceiling(x)
[1] 8
> floor(x)
[1] 7
> trunc(x)
[1] 7
> signif(x, 2)
[1] 7.6
Ejemplo 5.6. En un ejercicio de cálculo del tamaño muestral se obtiene n =

127,13. ¿Cuántos sujetos se necesitan?
Como el número de sujetos no puede tener decimales, el resultado de-
be redondearse menor entero superior a n, por tanto, utilizando la función
ceiling().
> ceiling(127.13)
[1] 128
5.3.2. Matemáticas generales

El sistema R tiene implementadas bastantes funciones matemáticas (Tabla
5.3).
√
Ejemplo 5.7. Para x = 7,6459871, calcule: a) ln x, b) x, c) ex y d) |x|.
> log(x)
[1] 2.034181
> sqrt(x)
[1] 2.765138
> exp(x)
[1] 2092.233
> abs(x)
[1] 7.645987
Como ejercicios de ((uso de R como calculadora)) vamos a plantear unos

problemas relacionados con el cálculo de la superficie corporal utilizando las
fórmulas de DuBois 1 y de Mosteller 2 . En estos problema se piden las solucio-
nes expresadas en metros cuadrados con dos decimales.
1 Du Bois y Du Bois publicaron una fórmula en 1916 en el que relacionaban la superficie corporal
(cm2 ) con el peso (kg) y la talla (cm):

SC = 71,84 × P ESO0,425 × T ALLA0,725
2 Mosteller publicó en 1987 otra fórmula más sencilla para calcular la superficie corporal (m2 )
con el peso en kg y la talla en cm:

r
P eso × T alla
SC =
3600

5.3. FUNCIONES AVANZADAS 49
Tabla 5.3: Funciones matemáticos avanzadas
www.editorialuc.es
Operador Función
abs(a) Calcula el valor absoluto de a
choose(n,a) Combinaciones de n elementos tomados de a en a
exp(a) Elevación del número e a una determinada potencia (a)
expm1(a) Calcula ea − 1 de forma segura cuando |a| 1
factorial(a) Calcula a!
gamma(a) Calcula Γa
lgamma(a) Logaritmo neperiano de Γa
log(a) Logaritmo neperiano de a
log(a, n) Logaritmo de a en base n
log10(a) Logaritmo decimal de a (son los logaritmos comunes)
log1p(a) Calcula de forma segura ln(1 + a) cuando |a| 1
log2(a) Logaritmo de a en base 2
rnorm(a) Genera a números aleatorios de una distribución nor-
mal
runif(a) Genera a números aleatorios entre 0 y 1 de una distri-
bución uniforme
sqrt(a) Raı́z cuadrada de a
Ejemplo 5.8. Calcule la superficie corporal de una mujer que pesa 57.3 kg y
mide 164.5 cm empleando la fórmula de Du Bois y Du Bois [141].
> round(71.84 * 57.3ˆ0.425 * 164.5ˆ0.725 / 10000, 2)

[1] 1.62
Ejemplo 5.9. Calcule ahora con la fórmula de Mosteller [142]. ¿Son los resul-
tados bastante parecidos?
> round(sqrt(57.3 * 164.5 / 3600), 2)

[1] 1.62
5.3.3. Trigonométricas
Las funciones trigonométricas (Tabla 5.4) aplican una función a un valor
(ecuación 5.4). La función trigonométrica solo tiene un argumento:
F U N CION (a) (5.4)
Hay otras funciones hiperbólicas que no usaremos en este libro.

Tabla 5.4: Funciones trigonométricas
Operador Función
sin(a) seno de a en radianes
cos(a) coseno de a en radianes
tan(a) tangente de a en radianes
asin(a) arco cuyo seno es a
acos(a) arco cuyo coseno es a
atan(a) arco cuya tangente es a
Ejemplo 5.10. Suponga que quiere calcular el ángulo de Cobb [143] en una
radiografı́a (ver Figura 5.2) y no tiene a mano un goniómetro o un transporta-
dor de ángulos, pero tras trazar las lı́neas del ángulo ((B)) y una perpendicular
a una de ellas, quiere calcular el ángulo de la escoliosis de la curva lumbar.
Primero mide la longitud de estas dos últimas (36 y 2.1 cm respectivamen-
te). Sabe que la tangente de un ángulo es el cociente entre el cateto opuesto y
el adyacente. Por lo tanto, calculando el arco tangente tendremos el ángulo en
radianes, que posteriormente convertiremos en grados y redondearemos a 0
decimales.
> round(atan(36/2.1) * 360/(2*pi))

[1] 87
Ejemplo 5.11. Calcule el ángulo de Cobb de la curva torácica (ángulo ((A))),

sabiendo que las longitudes de las dos lı́neas son 24 y 23 cm respectivamente.
> round(atan(24/23) * 360/(2*pi))

[1] 46

Tabla:
Función Acción
abs(a) Calcula el valor absoluto de a
acos(a) arco cuyo coseno es a
acosh(a) arco cuyo coseno hiperbólico es a
asin(a) arco cuyo seno es a
asinh(a) arco cuyo seno hiperbólico es a
atan(a) arco cuya tangente es a
atanh(a) arco cuya tangente hiperbólica es a
ceiling(a) Menor entero mayor que a
choose(n,a) Combinaciones de n elementos tomados de a en a

Función Acción
cos(a) coseno de a en radianes
www.editorialuc.es
cosh(a) coseno hiperbólico de a
exp(a) Elevación del número e a una determinada potencia (a)
expm1(a) Calcula ea − 1 de forma segura cuando |a| 1
factorial(a) Calcula a!
floor(a) Mayor entero menor que a
gamma(a) Calcula Γa
lgamma(a) Logaritmo neperiano de Γa
log(a) Logaritmo neperiano de a
log(a, n) Logaritmo de a en base n
log10(a) Logaritmo decimal de a (son los logaritmos comunes)
log1p(a) Calcula de forma segura ln(1 + a) cuando |a| 1
log2(a) Logaritmo de a en base 2
rnorm(a) Genera a números aleatorios de una distribución normal
round(a, d) Redondea a con d decimales
runif(a) Genera a números aleatorios entre 0 y 1 de una distribu-
ción uniforme
signif(a, d) Presenta a con d dı́gitos en notación cientı́fica
sin(a) seno de a en radianes
sinh(a) seno hiperbólico de a
sqrt(a) Raı́z cuadrada de a
tan(a) tangente de a en radianes
tanh(a) tangente hiperbólica de a
trunc(a) Elimina los decimales de (a) hacia 0
PROBLEMAS
Problema 1. Según el Padrón Municipal (datos del INE), la cifra de población de
Cantabria referida al 1 de enero de 2015 era de 585 179, de los que 300 391 eran mu-
jeres. Se le pide que calcular el porcentaje de hombres, expresado con un decimal.
Problema 2. En un determinado servicio hospitalario compuesto por 9 facultativos
se realizan guardias de dos personas. ¿Cuántas combinaciones diferentes se pueden
formar?
Problema 3. En ese mismo servicio se quieren repartir 9 despachos entre sus facul-
tativos. ¿Cuántos repartos (ordenaciones) posibles se pueden efectuar?
Problema 4. Una mujer de 34 años mide 163 cm de altura y pesa 52 kg, ¿qué super-
ficie corporal (m2 ) tiene según la fórmula de Du Bois?
Problema 5. La mujer del problema anterior, ¿qué superficie corporal (m2 ) tiene
según la fórmula de Mosteller?
Problema 6. En una consulta antropométrica se mide el perı́metro del brazo de una
adolescente de 17 años, que mide 20.4 cm. ¿Cuánto mide el radio de su brazo?

Figura 5.2: Radiografı́a de la CV en un sujeto con escoliosis.

www.editorialuc.es
Capı́tulo 6
El sistema de ayuda en R
Cuando se está aprendiendo un lenguaje de programación y análisis es-

tadı́stico es muy importante tener una buena ayuda sobre todos los elementos
que se utilizan y, en especial, sobre las funciones. Éstas suelen admitir varios
parámetros y es imposible recordar todos, sobre todo en las funciones que se
emplean con menor frecuencia. R tiene una excelente ayuda.
Las páginas de ayuda contiene mucha información útil y en muchas ocasio-
nes ejemplos sorprendentes. Son muy útiles por las referencias a otras funcio-
nes relacionadas. También presentan bibliografı́a muy relevante sobre el tema
en cuestión.
6.1. Las funciones de ayuda

R dispone de diversas funciones que permiten al usuario extraer la ayuda
que precise de entre toda la completı́sima información de que se acompaña.
6.1.1. La función ((help())) o ((?))

La función help() o su equivalente más sencillo de utilizar ? permiten
buscar ayuda sobre un objeto. Con ? se escribe el signo de interrogación y el
nombre del objeto sobre el que se busca información. Ası́, si se desea buscar
ayuda sobre la función que calcula la media de los elementos contenidos en un
vector, se teclea ?mean e inmediatamente aparece una ventana con la ayuda
(Figura 6.1). Los mismo resultados habrı́amos obtenido con help("mean") o
con help(mean). No es necesario entrecomillar la palabra, excepto cuando se
trata de determinadas palabras ?"for" o ?"[[".
La ayuda que ofrece presenta una primera lı́nea con la palabra buscada
(mean), después en qué paquete está (package:base) y finalmente dice que
se trata de la documentación del programa (R documentation). A conti-
nuación, tras un tı́tulo (Mean Arithmetic) la ayuda se desglosa en diversos
epı́grafes, no todos presentes (depende de qué ayuda se haya solicitado).
53
54 CAPÍTULO 6. EL SISTEMA DE AYUDA EN R
Figura 6.1: Ventana con la ayuda sobre la función mean() de R.
6.1.2. La función ((help.search()))

En el apartado anterior se vio que cuando se deseaba buscar ayuda sobre
una función se escribı́a el nombre de la función como argumento de la función
help(función). En ocasiones no se recuerda el nombre exacto de la función
o se quiere buscar ayuda sobre algunas palabras. En este caso hay que usar la
función help.search(), utilizando como argumento la palabra o palabras
entrecomilladas.
#---------------------------------------------------------------
help.search(pattern, fields = c("alias", "concept", "title"),
apropos, keyword, whatis, ignore.case = TRUE,
package = NULL, lib.loc = NULL,
help.db = getOption("help.db"),
verbose = getOption("verbose"),
rebuild = FALSE, agrep = NULL, use_UTF8 = FALSE,
types = getOption("help.search.types"))
#---------------------------------------------------------------
Ejemplo 6.1. Busque ayuda sobre modelos lineales.
> help.search("linear models")

> ??"linear models" # obtiene el mismo resultado
Help files with alias or concept or title matching ’linear models’ using
fuzzy matching:
boot::cv.glm Cross-validation for Generalized Linear Models

boot::glm.diag Generalized Linear Model Diagnostics
boot::glm.diag.plots Diagnostics plots for generalized linear models
MASS::boxcox Box-Cox Transformations for Linear Models
MASS::glm.nb Fit a Negative Binomial Generalized Linear Model
MASS::lm.gls Fit Linear Models by Generalized Least Squares

6.1. LAS FUNCIONES DE AYUDA 55
MASS::loglm Fit Log-Linear Models by Iterative Proportional

Scaling
www.editorialuc.es
MASS::loglm1 Fit Log-Linear Models by Iterative Proportional
Scaling -- Internal function
MASS::rlm Robust Fitting of Linear Models
MASS::stdres Extract Standardized Residuals from a Linear
Model
MASS::studres Extract Studentized Residuals from a Linear Model
MASS::summary.rlm Summary Method for Robust Linear Models
Matrix::lm.fit.sparse Fitter Function for Sparse Linear Models
mgcv::bam Generalized additive models for very large
datasets
mgcv::bam.update Update a strictly additive bam model for new
data.
mgcv::gam Generalized additive models with integrated
smoothness estimation
nlme::gls Fit Linear Model Using Generalized Least Squares
nlme::gnls Fit Nonlinear Model Using Generalized Least
Squares
nlme::recalc Recalculate Condensed Linear Model Object
nnet::multinom Fit Multinomial Log-linear Models
stats::anova.glm Analysis of Deviance for Generalized Linear Model
Fits
stats::anova.lm ANOVA for Linear Model Fits
stats::anova.mlm Comparisons between Multivariate Linear Models
stats::glm Fitting Generalized Linear Models
stats::family.glm Accessing Generalized Linear Model Fits
stats::lm Fitting Linear Models
stats::family.lm Accessing Linear Model Fits
stats::lm.fit Fitter Functions for Linear Models
stats::loglin Fitting Log-Linear Models
stats::predict.lm Predict method for Linear Model Fits
stats::selfStart Construct Self-starting Nonlinear Models
stats::summary.glm Summarizing Generalized Linear Model Fits
stats::summary.lm Summarizing Linear Model Fits
Otro ejemplo, queremos realizar un test de Kolmogorov-Smirnov, pero no

recordamos cómo se escribe exactamente su nombre; si tecleamos help.search(’kolmog’)
o ??kolmog encontramos:
6.1.3. La función ((help.start()))

Esta función presenta la ayuda disponible en la página web de CRAN (Fi-
gura 6.3).
#---------------------------------------------------------------
help.start(update = FALSE, gui = "irrelevant",
browser = getOption("browser"), remote = NULL)
#---------------------------------------------------------------

6.1.4. La función ((apropos()))

La función apropos(texto) busca toda la ayuda existente sobre la cade-
na texto. Es similar a utilizar ??texto.
#---------------------------------------------------------------
apropos(what, where = FALSE, ignore.case = TRUE, mode = "any")
find(what, mode = "any", numeric = FALSE, simple.words = TRUE)

#---------------------------------------------------------------
Ejemplo 6.2. Encuentre todo lo que haya sobre la cadena ”wilc”.
> apropos(’wilcox’)
[1] "dwilcox" "pairwise.wilcox.test"
[3] "pwilcox" "qwilcox"
[5] "rwilcox" "wilcox.test"
6.1.5. La función ((example()))

Esta función permite explorar el uso de prácticamente la totalidad de las
funciones existentes en R. Es aconsejable utilizarla en la primera ocasión que
se utilice una nueva función, ya que es una buena forma de conocer qué hace.
También se puede aprovechar el código según nuestras necesidades [144].
#---------------------------------------------------------------
example(topic, package = NULL, lib.loc = NULL,
character.only = FALSE, give.lines = FALSE, local = FALSE,
echo = TRUE, verbose = getOption("verbose"),

6.1. LAS FUNCIONES DE AYUDA 57
setRNG = FALSE, ask = getOption("example.ask"),

prompt.prefix = abbreviate(topic, 6),
www.editorialuc.es
run.dontrun = FALSE, run.donttest = interactive())
#---------------------------------------------------------------
Ejemplo 6.3. Vea un ejemplo sobre la función mean().
> example(mean)
mean> x <- c(0:10, 50)
mean> xm <- mean(x)
mean> c(xm, mean(x, trim = 0.10))

[1] 8.75 5.50
6.1.6. La función ((vignette()))

Esta función presenta las ((viñetas)) existentes en R. Se trata de documentos
en formato PDF que explican más detalladamente un determinado aspecto de
R o de alguno de sus paquetes.
vignette() abre una ventana donde aparecen todas las viñetas existentes
correspondientes a los paquetes que tengamos instalados en nuestro ordena-
dor (Figura 6.4).
Figura 6.4: Viñetas existentes en los paquetes instalados de R.
vignette(package = ’grid’) abre una ventana donde aparecen to-

das las viñetas existentes correspondientes al paquete especificado (Figura 6.5).
vignette(’rotated’) abre la viñeta especificada, en este caso rotated
(Figura 6.6).

Figura 6.5: Viñetas correspondiente al paquete grid.
6.2. Otras funciones de ayuda

6.2.1. La función ((find()))
La función find() con el nombre entrecomillado de una función nos in-
forma en qué paquete está esta función. Resultados similares se consiguen con
la función apropos().
#---------------------------------------------------------------
find(what, mode = "any", numeric = FALSE, simple.words = TRUE)
apropos(what, where = FALSE, ignore.case = TRUE, mode = "any")
#---------------------------------------------------------------
Ejemplo 6.4. Queremos saber en qué paquete está la función summ().
> find(’summ’)
[1] "package:epicalc"
6.2.2. La función ((demo()))

La función demo() permite ver una demostración de alguna caracterı́stica
implementada.
#---------------------------------------------------------------
demo(topic, package = NULL, lib.loc = NULL,
character.only = FALSE, verbose = getOption("verbose"),
echo = TRUE, ask = getOption("demo.ask"),
encoding = getOption("encoding"))
#---------------------------------------------------------------

6.3. LA FUNCIÓN ((HISTORY())) 59
www.editorialuc.es
Figura 6.6: Primera página de la viñeta rotated del paquete grid.
Ejemplo 6.5. Por ejemplo, teclee demo(persp), demo(graphics) o

demo(barplot).
Los resultados los verá en su ordenador...
6.3. La función ((history()))

Escribir código de programación es una tarea pesada y muchas veces re-
petitiva, de ahı́ que el ((cortar y pegar)) se utilice con frecuencia. Todos los co-
mandos y expresiones que se ejecuten durante una sesión de R están accesibles
mediante la función history(), lo que puede ser muy útil para repetir una
orden o para el ((corta y pega)).
#---------------------------------------------------------------
history(max.show = 25, reverse = FALSE, pattern, ...)
#---------------------------------------------------------------
También pulsando las teclas de ((↑)) o ((↓)) van apareciendo en la consola de

R las expresiones tecleadas anteriormente.

Tabla:
Función Acción
? Ayuda sobre una función (ejemplo, ?mean
apropos() Ayuda sobre todo lo relacionado con ’cadena’
demo() Demostración de alguna caracterı́stica implementada

Función Acción
example() Ejemplos de trabajo de una función
find() Presenta en qué paquete está una determinada función
help() Ayuda sobre un objeto o función
help.search() Buscar ayuda sobre un objeto o función
help.start() Ayuda en internet
history() Comandos tecleados
local() Evalúa una expresión en un entorno de R
summ() Estadı́stica descriptiva de una variable
vignette() Viñetas de ayuda (si existen)
PROBLEMAS
Problema 1. Ejecute example(binconf).
Problema 2. Ejecute example(barplot) y vaya pulsando con el ratón en la
ventana gráfica conforme se lo solicite R˙
Problema 3. Hojee la viñeta Follow-up del paquete Epi.
Problema 4. En qué paquete se encuentra la función use?
Problema 5. ¿Existe alguna viñeta sobre una introducción a las matrices?
Problema 6. Encuentre un manual sobre Sweave.
Problema 7. ¿Qué argumentos tiene la función xyplot()?
Problema 8. ¿Qué devuelve la función lm()?
Problema 9. ¿Qué parámetros necesita la función chis.test()?
Problema 10. ¿Qué significa na.rm = TRUE en la función mean()?

www.editorialuc.es
Parte II
EL LENGUAJE R

www.editorialuc.es
Capı́tulo 7
Guı́a de estilo en R
Una buena técnica de escritura en R es importante. Probablemente se puede

manejar con un estilo incorrecto, pero si adopta unas prácticas elegantes de es-
critura su código probablemente sea mejor o, por lo menos, otros lo entenderán
mejor.
No existe una guı́a de estilo oficial de R, lo que ha propiciado diferentes
estilos de escritura, algunos francamente difı́ciles de leer, lo que ha obligado a
que varios autores se hayan esforzado en proporcionar unos criterios elegantes
de escritura [145–149].
En https://google.gitub.io/styleguide/Rguide.xml puede en-
contrar una guı́a. Más interesante me parece la aportación de Wickham [148]
que adoptaré junto con las matizaciones de Johnson [149]
7.1. Nombres
Los nombres de los objetos tienen mucha importancia en R, por lo que se
deberán aplicar las siguientes reglas.
7.1.1. Ficheros
Los nombres de los ficheros deben ser autoexplicativos, es decir, que de-
ben indicar qué hacen.
BIEN: Lectura_datos.R
LecturaDatos.R
MAL: lecturaDatos.R # no empieza con una mayúscula

Lectura.R # no es autoexplicativo
El nombre debe estar formado por una única cadena: si están formados
por varias palabras, únalas con un signo de subrayado (( )) o use la nota-
ción húngara.
LecturaDatos.R
63
64 CAPÍTULO 7. GUÍA DE ESTILO EN R
MAL: Lectura datos.R # dos palabras

Lectura.datos.R # separación con un punto
El nombre debe empezar por una mayúscula, aunque se permiten prefijos

con minúscula y números para facilitar tareas de ordenación.
a1_LecturaDatos.R
a2_Depuracion.R
MAL: lectura_datos.R # no empieza con mayúscula
Siempre deben acabar en ((.R))
MAL: lectura_datos.txt # no acaba en ((.R))
No deben llevar acento ortográfico (tilde).
BIEN: Depuración.R
MAL: Depuración.R # lleva una tilde
7.1.2. Objetos
Los nombres deben ser informativos1 [150] y concisos.
Los nombres para variables deben ser sustantivos y para las funciones
deben ser verbos.
Los nombres de las variables deben ir en minúsculas. Se pueden unir
varias palabras con el signo del subrayado (( )) o con notación húngara.
Es aconsejable usar (( )) para separación de palabras
Los nombres de las variables no deben llevar ((.))
Conviene evitar los nombres de las funciones y palabras reservadas de R.
7.2. Sintaxis
Todo operador debe ir rodeado por un espacio delante y otro detrás, ex-
cepto los operadores ((:)), ((::)), ((:::))
BIEN: a <- 7
epicalc::des()
MAL: a<-7 # sin espacio antes y después

epı̀calc :: des() # espacios innecesarios
1 Según Jones et al. ((A good programming practice is to use informative names for your varia-
bles to improve readability)).

7.3. ESCRITURA DE CÓDIGO 65
La coma nunca lleva un espacio delante y siempre lleva un espacio detrás.
www.editorialuc.es
BIEN: mean(x, na.rm = TRUE)
MAL: mean(x,na.rm = TRUE)

mean(x , na.rm = TRUE)
Los paréntesis siempre llevan un espacio delante del de apertura y otro

detrás del de cierre, excepto en las funciones que no tienen ningún espa-
cio entre el nombre de la función y los paréntesis de los argumentos.
No utilice espacios extras dentro de los paréntesis.
7.3. Escritura de código

Es importante que el código se escriba correctamente para que sea enten-
dible pasado un tiempo. También es importante para que lo entiendan otros y
para facilitar la tarea de depuración.
Las lı́neas de código no deben superar los 70 caracteres (contando la iden-

taciones).
Una llave de apertura no debe estar sola en una lı́nea, mientras que una
llave de cierre sı́.
BIEN: f <- function(x) {

y <- 3 * x ˆ 2 - 4 * x + 5
y
}
MAL: f <- function(x)

{
y <- 3 * x ˆ 2 - 4 * x + 5
y
}
Emplee siempre dos espacios como identación. No utilice tabulaciones.
Puede emplear más de un espacio rodeando el operador de asignación si

mejora la alineación.
PERMITIDO: a <- 7
a2 <- 5
El operador de asignación debe ser <- y no =.
Utilice siempre TRUE y FALSE y no T y F.
Use nombres largos para variables que se usan rara vez y nombres cortos
para las que se usan con frecuencia.

66 CAPÍTULO 7. GUÍA DE ESTILO EN R
7.4. Documentación
Documente siempre su código. Lo que ahora le parece evidente, pasados
unos meses puede que no lo entienda.
¡Documente!
BIEN: # representación gráfica de la función seno

plot(1:63, sin(seq(0, 2 * pi, 0.1)))
MAL: chi_square <- function(M) {

tr <- M %*% rep(1, ncol(M))
tc<- rep(1, nrow(M)) %*% M
e <- (tr %*% tc) / sum(M)
chi2 <- sum((M - e) ˆ 2 / e)
chi2
}
Ponga cabeceras en sus scripts.
#==============================================#
# Fichero....: sb_01.R #
# Creado el..: 06jun2016 #
# Actualizado: 06jun2016 #
# Contenido..: Script del tema Tb01.tex #
# Autor......: Carlos G. Redondo Figuero #
#----------------------------------------------#
# Guı́a de estilo en R #
#==============================================#
Utilice solo una # en la documentación.
PROBLEMAS
Problema 1. Documente la función anterior que en el apartado ((Documentación)) se
ha catalogado como ((MAL)).
Problema 2. ¿El código de la función shapiro.test() respeta al 100 % lo reco-
mendado en este capı́tulo?

www.editorialuc.es
Capı́tulo 8
Sintaxis del lenguaje R
R es un lenguaje de programación para manipular objetos [102]. Para ser

capaz de programar en un lenguaje hay que conocer su gramática, su sintaxis
y su funcionalidad [151], de ahı́ que dediquemos este capı́tulo a su sintaxis y
semántica.
8.1. Comandos
Los comandos son la órdenes que se dan a R para que las ejecute1 .
Los comandos comienzan desde donde se empiezan a escribir (generalmen-
te al comienzo de la lı́nea, aunque los espacios en blanco que haya a su izquier-
da o ((sangrado)) no se tiene en consideración, por lo que se utilizan para hacer
más elegante la escritura del código) y acaban al final de una lı́nea o al encon-
trar una almohadilla #. Por eso ésta se utiliza para incluir comentarios en el
código que el compilador no tendrá en cuenta.
Los comandos están separados unos de otros por un punto y coma ; (se-
micolon) o por una nueva lı́nea. Esta segunda opción es más elegante ya que
ayuda a leer mejor el código.
Funciona: m <- mean(x); s <- sd(x)

Más elegante: m <- mean(x)
s <- sd(x)
En la consola se comienza a escribir después del prompt, que es una invita-

ción a escribir [152]. El sı́mbolo del apuntador es > y cuando se acaba la lı́nea
y no se ha completado la expresión el ((prompt)) cambia +, indicando que algo
falta.
> sum(12, 13
+ )
[1] 25
Por supuesto, cuando copie el código de los ejemplos de este libro no de-
berá teclear los signos ((>)) ni ((+)).
1 En palabras de Venables y Ripley: ((Commands to S are either expressions or assignments)) [102].
67
68 CAPÍTULO 8. SINTAXIS DEL LENGUAJE R
8.1.1. Expresiones
Un comando de expresión es una orden que se da a R para que la evalúe, la
ejecute y la imprima. Con una expresión siempre se obtiene un resultado.
Ejemplo 8.1. Se quiere calcular 7 + e2,35 .

Se teclea la siguiente expresión:
> 7 + exp(2.35)
[1] 17.48557
Ejemplo 8.2. Calcule la longitud de una circunferencia de radio 7 cm.

Como la longitud de una circunferencia es igual a 2πr, para calcular la del
ejemplo se teclea la siguiente expresión:
> 2 * pi * 7
[1] 43.9823
Se habrá dado cuenta que pi es el valor de π.
8.1.2. Asignaciones
Un comando de asignación, que utiliza el operador <- (assignment operator),
es una orden que se da a R para evaluar una expresión y pasar su valor a una
variable, pero no la imprime. Por ejemplo:
> x <- 2
Para que el código sea más legible se aconseja dejar un espacio antes y des-
pués del operador de asignación. No puede haber ningún espacio entre el signo
((menor)) y el signo ((menos)).
> x > x # método 1

[1] 2
> print(x) # método 2
[1] 2
> (x <- 2) # método 3
[1] 2
> show(x) # método 4
[1] 2
Se pueden utilizar asignaciones múltiples, que se van evaluando y ejecu-

tando de derecha a izquierda, como por ejemplo:
> x <- y <- z <- 2 # asignación múltiple

> x
[1] 2
> y
[1] 2
> z
[1] 2

8.2. OPERADORES 69
En general, las asignaciones múltiples no deben utilizarse, ya que compli-

can la legibilidad del código.
www.editorialuc.es
También se pueden agrupar varios comandos en una única expresión den-
tro de dos llaves {...}. El valor de esta expresión es el valor del último co-
mando (por tanto, los cálculos intermedios se pierden) [151].
> x <- {13; sqrt(49); log10(100); 15}
> x
[1] 15
Otro comando que puede ser útil en alguna ocasión es el que permite recu-
perar el último valor de una expresión: tecleando ((.Last.value)) se obtiene
el valor de la expresi√ón evaluada en último lugar. Supongamos que hemos
calculado 7 + e1,45 + 3 245,36 sin asignarlo a ninguna variable, pero luego que-
remos asignarle a la variable ((a)) sin tener que volver a teclearlo. Lo harı́amos
ası́:
> 7 + exp(1.45) + 245.36ˆ(1/3) # cálculo sin asignación
[1] 17.52350
> a <- .Last.value # asignación a la variable a
> a # se imprime el valor de a
[1] 17.52350
Ejemplo 8.3. La sentencia primer esguince tobillo izq <- "17 de

marzo de 2010", ¿es correcta?
> (primer esguince_tobillo_izq <- "17 de marzo de 2010")

Error: inesperado sı́mbolo en "primer esguince_tobillo_izq"
La sentencia anterior es incorrecta, porque el nombre de la variable contiene

un espacio en blanco, por lo que R considera que se va a hacer una asignación
múltiple a dos variables, pero encuentra que falta un sı́mbolo de asignación.
Ejemplo 8.4. La sentencia segundo esguince tobillo izq <- "2 de

mayo de 2010", ¿es ahora correcta?
> (segundo_esguince_tobillo_izq <- "2 de mayo de 2010")

[1] "2 de abril de 2010"
Ahora es correcta porque el nombre del objeto es una única palabra.
8.2. Operadores
Un operador es una función (aunque no lo parezca) que realiza una opera-
ción sobre uno o más objetos. Por ejemplo el operador + aplicado a un vector
suma los elementos que están en la misma posición: el primer elemento de un
vector con el primero del otro, el segundo con el segundo, etc.
En el capı́tulo ((R Calculadora Cientı́fica)) se vieron los operadores básicos
(+, -, *, /, ˆ, % % y %/ %). Hay algunos: :, >, <, <=, >=, ==, !=, &, |, &&, ||, ˜,
<-, ->, =. Cuando en una expresión hay varios, unos tienen mayor preceden-
cia o importancia que otros y se ejecutan antes. Cuando hay dudas es mejor
separarlos con paréntesis.

> 2 + 5 ˆ 2
[1] 27
> (2 + 5) ˆ 2
[1] 49
La precedencia de los operadores se recoge en la Tabla 8.1 [94, 102, 145].
Tabla 8.1: Precedencia de los operadores
Operador Realiza
(, { Paréntesis y llaves
[, [[ Para extracción de vectores y de listas
::, ::: acceso a espacios nominados
$, @ Para extracción de listas y slots
ˆ Elevación a potencias
+, - Signo más y signo menos
: Generación de secuencias
% %, %/ %, %* % Otros operadores especiales
*, / Multiplicación y división
+, -, ? Suma, resta y documentación
<, >, <=, >=, ==, != Operadores de comparación
! Negación lógica
&, |, &&, || Operadores lógicos
˜ Fórmulas
<-, ->, = Asignación
Los operadores del tipo %any % pertenecen al lenguaje R, pero pueden de-
finirse algunos por el propio usuario; por ejemplo:
> ’%p%’ <- function(x1, x2) paste(x1, x2, sep = ’’)

> ’Curso’ %p% ’R’
[1] "CursoR"
La función xor() computa el ((OR)) exclusivo elemento a elemento de sus

dos argumentos [151].
> set.seed(2016) # fija la semilla de aleatorización

> (x <- sample(c(TRUE, FALSE), 10, replace = TRUE))
[1] TRUE TRUE FALSE TRUE TRUE TRUE FALSE FALSE TRUE TRUE
> (y <- sample(c(TRUE, FALSE), 10, replace = TRUE))
[1] TRUE TRUE TRUE FALSE TRUE TRUE FALSE TRUE FALSE TRUE
> x & y # AND
[1] TRUE TRUE FALSE FALSE TRUE TRUE FALSE FALSE FALSE TRUE
> x | y # OR
[1] TRUE TRUE TRUE TRUE TRUE TRUE FALSE TRUE TRUE TRUE
> xor(x, y) # XOR
[1] FALSE FALSE TRUE TRUE FALSE FALSE FALSE TRUE TRUE FALSE
> !x # NOT
[1] FALSE FALSE TRUE FALSE FALSE FALSE TRUE TRUE FALSE FALSE

8.3. FUNCIONES 71
8.3. Funciones
www.editorialuc.es
Todo en R son funciones. Una función es como una caja negra: admite unos
parámetros como entrada llamados argumentos (agruments), trabaja con ellos
en su interior y luego ofrece unos resultados como salida (output function). En
R, todo el trabajo se hace con funciones [145].
La funciones permiten una programación modular [153], ya que los usua-
rios interactúan con el software por medio de las funciones. su sintaxis es:
f <- function(...) {
trabajo interno
salida
}
Los elementos de una función son los siguientes:

f es el nombre de la función (debe empezar con una letra).
<- es el operador de asignación.
function es una palabra reservada de R indicadora de que se está creando
una función (siempre debe ir en minúsculas).
(...) son los parámetros de la función separados por comas y encerrados
entre paréntesis. Algunas funciones no necesitan ningún parámetro, pero
otras admiten hasta dos tipos: unos, que van en primer lugar y no suelen
tener nombre, y otros que tienen nombre.
{ } son las llaves de apertura y cierre (curly braces) que delimitan lo que hace
la función (((caja negra))).
salida es lo último que hace la función. A veces se explicita con return()
o como invisible().
Ejemplo 8.5. Programe una función que calcule la varianza de un vector

numérico.
La varianza de una variable numérica se calcula con la ecuación siguiente:
(x − x̄)2
P
var(x) = (8.1)
n−1
> varianza <- function(x) {
+ x <- x[!is.na(x)] # se eliminan los NA
+ n <- length(x) # n
+ m <- mean(x) # media
+ v <- sum((x - m) ˆ 2) / (n - 1) # variancia
+ return(varianza = v)
+ }
> # ejemplo
> set.seed(2016)
> x <- rnorm(500)
> varianza(x) # nuestra función
[1] 0.9690002
> var(x) # la variancia de R
[1] 0.9690002

Las funciones ofrecen grandes posibilidades al usuario de R, pero su pro-

gramación exige un conocimiento del lenguaje R, como veremos en los próxi-
mos capı́tulos.
Antes de programar una función hay que comprobar que R o alguno de sus
paquetes no ofrezcan ya esa solución. Por ejemplo, R tiene la función var()
que es la que debemos utilizar, en vez de la programada por nosotros.
#---------------------------------------------------------------
var(x, y = NULL, na.rm = FALSE, use)
#---------------------------------------------------------------

tablas:
Función Acción
c() Concetena elementos en un vector
exp() Número e elevado a un exponente
function() Crea una función
invisible() Hace invisible la salida de una función
is.na() Comprueba si es NA
length() Longitud de un objeto
log10() Logaritmo en base decimal
mean() Media de un vector
print() Imprime en la consola
return() Salida de una función
rnorm() Crea un vector de números aleatorios normales
sample() Extracción aleatoria
sd() Calcula la desviación estándar de un vector
set.seed() Fija la semilla de aleatorización
show() Imprime en la consola
sqrt() Calcula la raı́z cuadrada de los elementos de un vector
sum() Calcula la suma de los elementos de un vector
var() Calcula la varianza de un vector
varianza() Calcula la varianza de un vector
xor() OR exclusivo
Antes de finalizar este capı́tulo debe recordar:
Los cálculos en computación no son siempre exactos. Hay errores por

efecto del redondeo [154–159].
R es sensible a las mayúsculas2 , de manera que
> z <- 1:21
2 En palabras de Braun y Murdoch: ((R is case-sensitive.)) [160]

> mean(z)
[1] 11
www.editorialuc.es
> MEAN(z)
Error: no se pudo encontrar la función "MEAN"
> MEAN <- mean
> MEAN(z)
[1] 11
PROBLEMAS
Problema 1. Si n <- 1:10, ¿qué resultado obtendrá con 1.25 * (n * 0.8)

- n? Adelante se respuesta y compruebe si es correcta.
Problema 2. Complete la siguiente tabla utilizando alguna expresión de R y explique
los resultados del operador ((OR)).
OR
Value NA FALSE TRUE
NA ? ? ?
FALSE ? ? ?
TRUE ? ? ?
Problema 3. Diga si es cierto o falso: 2 < 4.

Problema 4. Diga si es cierto o falso: 2 > -3 .
Problema 5. Diga si es cierto o falso: -3 > -8.
Problema 6. Diga si es cierto o falso: 3 != abs(-3).
los resultados del operador ((XOR)).
XOR
Value NA FALSE TRUE
NA ? ? ?
FALSE ? ? ?
TRUE ? ? ?

los resultados del operador ((AND)).
Problema 9. Cree el operador %div % que nos diga si un número a es divisible por
un número b.
Problema 10. Escriba una única lı́nea de código que asigne a una variable el resul-
tado de una función y la imprima.

AND
Value NA FALSE TRUE
NA ? ? ?
FALSE ? ? ?
TRUE ? ? ?
Problema 11. Programer la función trig() que admita como parámetros los gra-
dos sexagesimales y devuelva un vector de tres cifras numéricas correspondientes al
seno, coseno y tangente de un ángulo. Compruebe que da la siguiente salida.
> trig(87)
seno coseno tangente
0.99862953 0.05233596 19.08113669
Problema 12. Intente adivinar el resultado de la siguiente expresión sum(xor(x,

y)). Compruebe que su respuesta es correcta.
Problema 13. Sea a <- c(TRUE, TRUE, FALSE) y b <- c(0, 0, 1)
¿Cuál será el resultado de a & b?
Problema 14. Continuando con el problema anterior. Adelante cuál será el resultado
de a && b y compruébelo posteriormente.

www.editorialuc.es
Capı́tulo 9
Objetos
En cualquier lenguaje de programación los datos se almacenan en la memo-

ria. R no permite el acceso directo a la memoria del ordenador, sino que pone
los datos en unas estructuras especializadas llamadas objetos, que pueden ser
referidos como sı́mbolos o variables. Cualquier cosa en R es un objeto1 [92] y
su referencia fundamental es un nombre [161] 2 .
9.1. Nombre
Los objetos en R pueden ser nombrados por palabras formadas por: (1) le-
tras (mayúsculas, minúsculas e incluso acentuadas), (2) dı́gitos del 0 al 9 (pero
no en posición inicial), (3) el . que se suele utilizar para separar palabras com-
puestas, pero que no debiera estar en posición inicial ya que las variables que
comienzan con un . suelen ser palabras utilizadas internamente en el progra-
ma, y (4) el signo de subrayado se puede utilizar para separar palabras.
No se permiten espacios en blanco entre palabras, pues se considerarı́an
como varios objetos, de forma que para formar una palabra compuesta se pue-
den intercalar puntos o el guión-bajo entre las palabras o ponerlas juntas con
la primera letra en mayúscula, conocida como ((notación húngara)), que es un
sistema usado normalmente para crear los nombres de variables en lenguajes
de programación. El nombre de la notación proviene de su inventor, el húnga-
ro Charles Simonyi (Figura 9.1) [163]. Éste se hizo multimillonario por ser el
creador de la suite ofimática Office de Microsoft.
Son correctas:
> IMC <- 23.45

> Imc <- 24.00
> imc <- 24.56
> a3 <- 7
> a3.inicio <- 2
> IndiceMasaCorporal <- 23.76
> indice_masa_corporal <- 23.76
1 ((Everything
within the S language is an object, even the functions and operators)) [151].
el propio Chambers: ((To understand computations in R, two slogans are helpful: (1)
2 Según
Everything that exists is an object. (2) Everything that happens is a function call)). [162]
75
76 CAPÍTULO 9. OBJETOS
Figura 9.1: El húngaro, nacionalizado norteamericano, Charles Simonyi (10sep1948),

((padre)) de Excel y Word, en su segundo vuelo espacial turı́stico.
Son incorrectas:
.IMC <- 23.45 # correcta pero NO debe usarse

3a <- 24.00 # empieza por un número
indice masa corporal <- 23.76 # hay espacios en blanco
indice-masa-corporal <- 23.76 # operador: signo menos
indice#masa#corporal <- 23.76 # sı́mbolo de comentario
indice-masa!corporal <- 23.76 # sı́mbolos menos y de admiración
9.1.1. Palabras reservadas

Son las que no se pueden utilizar para nombrar objetos porque tiene un
significado especial en R (Tabla 9.1, lado izquierdo). Su uso puede ocasionar
problemas [151]. Ejecute el siguiente código para que vea los errores:
break <-1 # palabra reservada (no usar)

else <-2 # palabra reservada (no usar)
FALSE <-3 # palabra reservada (no usar)
for <-4 # palabra reservada (no usar)
function <-5 # palabra reservada (no usar)
if <-6 # palabra reservada (no usar)
in <-7 # palabra reservada (no usar)
Inf <-8 # palabra reservada (no usar)
NA <-9 # palabra reservada (no usar)
NaN <- 10 # palabra reservada (no usar)
next <- 11 # palabra reservada (no usar)
NULL <- 12 # palabra reservada (no usar)
repeat <- 13 # palabra reservada (no usar)
TRUE <- 14 # palabra reservada (no usar)
while <- 15 # palabra reservada (no usar)

9.2. MEMORIA 77
9.1.2. Palabras que deben ser evitadas

Son las que, aunque sı́ se pueden utilizar para nombrar objetos, se debe
www.editorialuc.es
evitar porque tienen un significado especial en R (Tabla 9.1, lado derecho) y
pueden causar problemas difı́ciles de detectar [102].
Tabla 9.1: Palabras reservadas que no deben utilizarse para nombrar objetos y palabras
que den evitarse
Palabras reservadas (15) Palabras que deben evitarse

break if next c I range t
else in NULL C length rank T
FALSE Inf repeat D mean return time
for NA TRUE diff pi s tree
function NaN while F q sd var
Algunas son empleadas por R, por lo que pueden causar confusión si se

emplean con otros fines, en especial T y F que son abreviaturas de TRUE y
FALSE que si se redefinen después no trabajarán correctamente [95].
9.2. Memoria
Cuando arranca R se crea un espacio de trabajo donde el usuario crea y
manipula variables [94]. Todos los objetos que usa R están en la memoria, en
un marco determinado (environment) en el que se pueden crear, salvar o borrar.
Hay un entorno llamado ((workspace)) donde están los objetos con los que se
puede trabajar (variables, bases de datos, funciones creadas por el usuario)3 .
En la Tabla 9.2 se presentan las funciones relacionadas.
Tabla 9.2: Funciones en relación con los objetos y la memoria
Funciones Significado
ls() Lista los objetos del entorno de trabajo
objects() Idem
rm() Remueve los objetos del entorno de trabajo
remove() Idem
#---------------------------------------------------------------
ls(name, pos = -1L, envir = as.environment(pos),
objects(name, pos= -1L, envir = as.environment(pos),
#---------------------------------------------------------------
3 Según Robert Gentelman, uno de los padres de R, ((An environment is a set of bindings of names, or
symbols, to values. The top-level workspace can be accessed through its name, which is .GlobalEnv [94].))

La función ls() lista todos los objetos que hay en el entorno, excepto los
que comienzan por un punto.
Ejemplo 9.1. Liste los objetos que tiene en memoria (puede ser que no le
aparezca ninguno si no ha creado ninguno).
> ls()
character(0)
Ejemplo 9.2. Cree un objeto x que contenga los 100 primeros números natu-
rales. Lı́stelo, bórrelo y compruebe que ya no existe.
> x <- 1:100

> x
[1] 1 2 3 4 5 6 7 8 9 10 11 12 13 14
[15] 15 16 17 18 19 20 21 22 23 24 25 26 27 28
----------------------- lı́neas omitidas ----------------------
[85] 85 86 87 88 89 90 91 92 93 94 95 96 97 98
[99] 99 100
> ls()
[1] "x"
> rm(x)
> ls()
character(0)
Ejemplo 9.3. Cargue el paquete epicalc. ¿Qué objetos tiene en el environ-

ment-2? Lı́stelos.
> library(epicalc)
> ls(2)
[1] "addMissingRecords" "adjust"
[3] "aggregate.numeric" "aggregate.plot"
[5] "alpha" "alphaBest"
[7] "auc" "be2ad"
[9] "cc" "cci"
[11] "ci" "ci.binomial"
[13] "ci.default" "ci.numeric"
[15] "ci.poisson" "clogistic.display"
[17] "codebook" "cox.display"
[19] "cs" "csi"
[21] "des" "detachAllData"
[23] "dotplot" "expand"
[25] "fillin" "followup.plot"
[27] "graph.casecontrol" "graph.prospective"
[29] "idr.display" "kap"
[31] "kap.2.raters" "kap.ByCategory"
[33] "kap.default" "kap.m.raters"
[35] "kap.table" "keepData"
[37] "label.var" "labelTable"
[39] "lagVar" "logistic.display"
[41] "lookup" "lroc"
[43] "lrtest" "lsNoFunction"

9.3. PROPIEDADES 79
[45] "make2x2" "markVisits"

[47] "matchTab" "merge.lab"
www.editorialuc.es
[49] "mhor" "mlogit.display"
[51] "n.for.2means" "n.for.2p"
[53] "n.for.cluster.2means" "n.for.cluster.2p"
[55] "n.for.equi.2p" "n.for.lqas"
[57] "n.for.noninferior.2p" "n.for.survey"
[59] "ordinal.or.display" "pack"
[61] "poisgof" "power.for.2means"
[63] "power.for.2p" "print.alpha"
[65] "print.cci" "print.des"
[67] "print.display" "print.kap.ByCategory"
[69] "print.kap.table" "print.lrtest"
[71] "print.n.for.2means" "print.n.for.2p"
[73] "print.n.for.cluster.2means" "print.n.for.cluster.2p"
[75] "print.n.for.equi.2p" "print.n.for.lqas"
[77] "print.n.for.noninferior.2p" "print.n.for.survey"
[79] "print.power.for.2means" "print.power.for.2p"
[81] "print.summ" "print.tab1"
[83] "print.tableStack" "pyramid"
[85] "recode" "recode.default"
[87] "recode.is.na" "regress.display"
[89] "ren" "rename"
[91] "rename.default" "rename.pattern"
[93] "rename.var" "roc.from.table"
[95] "setTitle" "shapiro.qqnorm"
[97] "sortBy" "summ"
[99] "tab1" "tableGlm"
[101] "tableStack" "tabpct"
[103] "tally.events" "titleString"
[105] "unclassDataframe" "use"
[107] "zap"
9.3. Propiedades
Cualquier cosa en R es un objeto, incluso las funciones y los operadores
[151]. Las distintas funciones que se pueden utilizar en relación con los obje-
tos quedan recogidas en la Tabla 9.3, y nos permiten explorar las diferentes
caracterı́sticas de los objetos.
Para explorar las diferentes propiedades de los objetos vamos a declarar
cuatro objetos:
> x <- (1:4) / 4 # vector numérico

> y <- ’Marı́a’ # vector de cadenas
> z <- c(TRUE, TRUE, FALSE) # vector lógico
> w <- cbind(1:4, 11:14, 21:24) # matriz
9.3.1. Atributos
La función attributes() informa de los atributos del objeto (cuando los
tiene, de lo contrario su resultado es NULL. La función attr() permite acceder
a un determinado atributo. Se pueden declarar atributos para cualquier objeto.

Tabla 9.3: Funciones en relación con las propiedades de los objetos
Funciones Significado
attr() permite cambiar un atributo
attributes() atributos
class() clase del objeto
dim() dimensiones
length() longitud del objeto (número de componentes)
mode() modo de almacenamiento del objeto
names() nombres de los componentes
str() estructura resumida del objeto
structure() estructura amplia del objeto
storage.mode() modo de almacenamiento
typeof() tipo de objeto
Los atributos se almacenan en una lista según sus nombres. Son muy utilizados
por los programadores.
#---------------------------------------------------------------
attributes(obj)
attributes(obj) <- value
#---------------------------------------------------------------
Ejemplo 9.4. ¿Qué atributos tiene el vector x?
> attributes(x) # no tiene

NULL
Ejemplo 9.5. Asigne al vector x los atributos de ((nombre)), ((longitud)) y

((almacena)).
> attributes(x) <- list(nombre = ’vector numérico’,

+ longitud = 4,
+ almacena = ’probabilidades’)
> attributes(x)
$nombre
[1] "vector numérico"
$longitud
[1] 4
$almacena
[1] "probabilidades"
Ejemplo 9.6. Cambie el atributo ((probabilidades)) por ((prob.)).
> attr(x, ’probabilidades’) <- ’prob.’

> x

9.3. PROPIEDADES 81
[1] 0.1 0.2 0.3 0.4

attr(,"nombre")
www.editorialuc.es
[1] "vector numérico"
attr(,"longitud")
[1] 4
attr(,"almacena")
[1] "probabilidades"
attr(,"probabilidades")
[1] "prob."
9.3.2. Clase
La función class() informa de qué clase es el objeto. También permite
asignar una clase.
#---------------------------------------------------------------
class(x)
class(x) <- value
#---------------------------------------------------------------
Ejemplo 9.7. ¿De qué clase son los objetos x, y, z y w?
> class(x) # x es un vector numérico con 4 elementos

[1] "numeric"
> class(y) # y es un vector de cadenas de caracteres
[1] "character"
> class(z) # z es un vector lógico
[1] "logical"
> class(w) # w es una matriz
[1] "matrix"
9.3.3. Dimensiones y Longitud

Las funciones dim() y length() informan de las dimensiones y de la
longitud del objeto.
#---------------------------------------------------------------
dim(x)
dim(x) <- value
length(x)
length(x) <- value
#---------------------------------------------------------------
> dim(x) # no tiene dimensiones

NULL
> length(y) # este vector solo tiene un elemento
[1] 1
> dim(w) # es una matriz de 4 filas y 3 columnas
[1] 4 3
> length(w) # tiene 12 elementos
[1] 12

Cuando cambia las dimensiones de un objeto puede que cambie la clase.
Ejemplo 9.8. Confirme que el objeto w es una matriz. Cambie sus dimensio-
nes a c(2, 2, 3 y compruebe si es de la misma clase.
> w # objeto de dimensión c(2, 2)

[,1] [,2] [,3]
[1,] 1 11 21
[2,] 2 12 22
[3,] 3 13 23
[4,] 4 14 24
> class(w) # es una matriz
[1] "matrix"
> dim(w) <- c(2, 2, 3) # se cambian sus dimensiones
> w # se imprime
, , 1
[,1] [,2]
[1,] 1 3
[2,] 2 4
, , 2
[,1] [,2]
[1,] 11 13
[2,] 12 14
, , 3
[,1] [,2]
[1,] 21 23
[2,] 22 24
> class(w) # es una array

[1] "array"
9.3.4. Nombres
La función names() presenta el nombre de cada uno de los elementos del
objeto (si los tiene). También sirve para asignar nombres.
#---------------------------------------------------------------
names(x)
names(x) <- value
#---------------------------------------------------------------
Los nombres son de mucha utilidad en la presentación de resultados.
Ejemplo 9.9. Suponga que ha hecho una estadı́stica descriptiva de un vector

numérico con tres variables que representan m la media 2.78, s la desviación
estándar 0.56 y n el número de casos 23. Presente los tres resultados en un
vector c(a, b, c). Asigne nombres y mejorará el resultado.

9.3. PROPIEDADES 83
> m <- 2.78 # media

> s <- 0.56 # DE
www.editorialuc.es
> n <- 23 # casos
> c(n, m, s) # presentación sin nombres
[1] 23.00 2.78 0.56
> c(N = n, media = m, DE = s) # presentación con nombres
N media DE
23.00 2.78 0.56
> rm(m, n, s) # se borran
9.3.5. Tipo
La función typeof() devuelve una cadena de caracteres entrecomillada
con el tipo de un objeto, cuyos posibles valores se detallan en la Tabla 9.4.
#---------------------------------------------------------------
typeof(x)
#---------------------------------------------------------------
Ejemplo 9.10. ¿De qué tipo son los objetos x, y, z y w?
> typeof(x)
[1] "double"
> typeof(y)
[1] "character"
> typeof(z)
[1] "logical"
> typeof(w)
[1] "integer"
9.3.6. Modo de almacenamiento

La función mode() da información sobre el modo de almacenamiento en
el sentido de Becker et al [88], es decir indica el modo o tipo básico de sus
constituyentes fundamentales.
#---------------------------------------------------------------
mode(x)
mode(x) <- value
storage.mode(x)
storage.mode(x) <- value
#---------------------------------------------------------------
Ejemplo 9.11. Determine los modos de los objetos x, y, z y w
> mode(x)
[1] "numeric"
> mode(y)
[1] "character"
> mode(z)
[1] "logical"
> mode(w)
[1] "numeric"

Tabla 9.4: Diferentes tipos de objetos en R.
Tipos Significado
NULL un objeto nulo
symbol un nombre de una variable
pairlist un objeto pairlist
closure una función
environment un entorno de trabajo
promise un objeto usado para implementar la evaluación lazy
language un constructor de lenguaje RR
special una función interna que no evalúa sus argumentos
builtin una función interna que evalúa sus argumentos
char una cadena de caracteres
logical un vector de valores lógicos
integer un vector de enteros
double un vector de números reales
complex un vector de números complejos
character un vector de caracteres
... un argumento especial de longitud variable
any cualquier tipo
expression un objeto expresión
list una lista
bytecode un código bit (uso interno)
externalptr un puntero externo
weakref un objeto de referencia weak
raw un vector que contiene bytes
S4 un objeto S4
La función storage.mode() proporciona información sobre el modo de

almacenamiento de sus argumentos. Generalmente se usa cuando se utilizan
funciones escritas en otro lenguaje de programación; por ejemplo, en C o en
FORTRAN, para asegurar que los objetos de R tienen la estructura de datos
adecuada a esa función.
Ejemplo 9.12. Determine los modos de almacenamiento de los objetos x, y,

z y w.
> storage.mode(x) # doble precisión

[1] "double"
> storage.mode(y) # caracteres
[1] "character"
> storage.mode(z) # lógicos
[1] "logical"
> storage.mode(w) # numérico
[1] "integer"

9.3. PROPIEDADES 85
9.3.7. Estructura
La función str() da información sobre la estructura del objeto, de una for-
www.editorialuc.es
ma resumida. Esta es una de las funciones que se utilizan con más frecuencia.
#---------------------------------------------------------------
str(object, max.level = NA,
vec.len = strO$vec.len, digits.d = strO$digits.d,
nchar.max = 128, give.attr = TRUE,
give.head = TRUE, give.length = give.head,
width = getOption("width"), nest.lev = 0,
indent.str = paste(rep.int(" ", max(0, nest.lev + 1)),
collapse = ".."),
comp.str = "$ ", no.list = FALSE, envir = baseenv(),
strict.width = strO$strict.width,
formatNum = strO$formatNum, list.len = 99, ...)
#---------------------------------------------------------------
Ejemplo 9.13. ¿Cuál es la estructura ((sencilla)) de los objetos x, y, z y w?
> str(x)
Named num [1:4] 0.1 0.2 0.3 0.4
- attr(*, "names")= chr [1:4] "A" "B" "C" "D"
> str(y)
chr "Marı́a"
> str(z)
logi [1:3] TRUE TRUE FALSE
> str(w)
int [1:2, 1:2, 1:3] 1 2 3 4 11 12 13 14 21 22 ...
La función structure() da información amplia sobre la estructura del

objeto.
#---------------------------------------------------------------
structure(.Data, ...)
#---------------------------------------------------------------
Ejemplo 9.14. ¿Cuál es la estructura ((ampliada)) de los objetos x, y, z y w?
> structure(x)
A B C D
0.1 0.2 0.3 0.4
> structure(y)
[1] "Marı́a"
> structure(z)
[1] TRUE TRUE FALSE
> structure(w)
, , 1
[,1] [,2]
[1,] 1 3
[2,] 2 4

, , 2
[,1] [,2]
[1,] 11 13
[2,] 12 14
, , 3
[,1] [,2]
[1,] 21 23
[2,] 22 24
9.4. Manipulación de objetos

En el área de trabajo están todos los objetos que se van creando cuando se
ejecuta una sesión de R, como ya se vio en la Tabla 9.2. La forma de evidenciar-
los es tecleando objects() o su equivalente, más sencillo de teclear, ls().
En la ventana ((Environment)) de RStudio se ven los objetos que existen.
Ejemplo 9.15. Liste los objetos que tiene en memoria.
> ls()
[1] "w" "x" "y" "z"
9.4.1. Creación
Los objetos se crean en memoria cuando se les asigna algo (por ejemplo,
a <- 22, crea un objeto llamado a que contiene el valor 22) o simplemen-
te declarando su tipo, aunque no contenga ningún valor (por ejemplo, b <-
numeric()).
9.4.2. Coerción
En algunas ocasiones interesa que un objeto de un determinado tipo cambie
a otro tipo diferente (coercion). Esto se logra con las funciones que se presentan
en la Tabla 9.5, unas sirven para hacer el cambio, y otras para comprobar que
el tipo es el adecuado.
Para ver todas las funciones is.* o as* existentes en el paquete base se
debe utilizar la función ls()
Ejemplo 9.16. Liste todas las funciones ((is.*)) existentes en el paquete base.
> ls(pattern = ’îs’, baseenv())

[1] "is.array" "is.atomic"
[3] "is.call" "is.character"
[5] "is.complex" "is.data.frame"
[7] "is.double" "is.element"
[9] "is.environment" "is.expression"
[11] "is.factor" "is.finite"
[13] "is.function" "is.infinite"
[15] "is.integer" "is.language"

9.4. MANIPULACIÓN DE OBJETOS 87
Tabla 9.5: Funciones que permiten comprobar (is.xxx) o cambiar (as.xxx) los atributos
de diferentes categorı́as de objetos
www.editorialuc.es
Tipo Comprobación Cambio
Array is.array() as.array()
Character is.character() as.character()
Complex is.complex() as.complex()
Dataframe is.data.frame() as.data.frame()
Double is.double() as.double()
Factor is.factor() as.factor()
List is.list() as.list()
Logical is.logical() as.logical()
Matrix is.matrix() as.matrix()
Numeric is.numeric() as.numeric()
Raw is.raw() as.raw()
Time serie is.ts() as.ts()
Vector is.vector() as.vector()
[17] "is.list" "is.loaded"

[19] "is.logical" "is.matrix"
[21] "is.na" "is.na.data.frame"
[23] "is.na.numeric_version" "is.na.POSIXlt"
[25] "is.na<-" "is.na<-.default"
[27] "is.na<-.factor" "is.na<-.numeric_version"
[29] "is.name" "is.nan"
[31] "is.null" "is.numeric"
[33] "is.numeric_version" "is.numeric.Date"
[35] "is.numeric.difftime" "is.numeric.POSIXt"
[37] "is.object" "is.ordered"
[39] "is.package_version" "is.pairlist"
[41] "is.primitive" "is.qr"
[43] "is.R" "is.raw"
[45] "is.recursive" "is.single"
[47] "is.symbol" "is.table"
[49] "is.unsorted" "is.vector"
[51] "isatty" "isBaseNamespace"
[53] "isdebugged" "isIncomplete"
[55] "isNamespace" "isNamespaceLoaded"
[57] "isOpen" "isRestart"
[59] "isS4" "isSeekable"
[61] "isSymmetric" "isSymmetric.matrix"
[63] "isTRUE"
Ejemplo 9.17. Liste todas las funciones ((as.*)) existentes en el paquete base.
> ls(pattern = "âs.", baseenv())

[1] "as.array" "as.array.default"
[3] "as.call" "as.character"
[5] "as.character.condition" "as.character.Date"

[7] "as.character.default" "as.character.error"

[9] "as.character.factor" "as.character.hexmode"
[11] "as.character.numeric_version" "as.character.octmode"
[13] "as.character.POSIXt" "as.character.srcref"
[15] "as.complex" "as.data.frame"
[17] "as.data.frame.array" "as.data.frame.AsIs"
[19] "as.data.frame.character" "as.data.frame.complex"
[21] "as.data.frame.data.frame" "as.data.frame.Date"
[23] "as.data.frame.default" "as.data.frame.difftime"
[25] "as.data.frame.factor" "as.data.frame.integer"
[27] "as.data.frame.list" "as.data.frame.logical"
[29] "as.data.frame.matrix" "as.data.frame.model.matrix"
[31] "as.data.frame.noquote" "as.data.frame.numeric"
[33] "as.data.frame.numeric_version" "as.data.frame.ordered"
[35] "as.data.frame.POSIXct" "as.data.frame.POSIXlt"
[37] "as.data.frame.raw" "as.data.frame.table"
[39] "as.data.frame.ts" "as.data.frame.vector"
[41] "as.Date" "as.Date.character"
[43] "as.Date.date" "as.Date.dates"
[45] "as.Date.default" "as.Date.factor"
[47] "as.Date.numeric" "as.Date.POSIXct"
[49] "as.Date.POSIXlt" "as.difftime"
[51] "as.double" "as.double.difftime"
[53] "as.double.POSIXlt" "as.environment"
[55] "as.expression" "as.expression.default"
[57] "as.factor" "as.function"
[59] "as.function.default" "as.hexmode"
[61] "as.integer" "as.list"
[63] "as.list.data.frame" "as.list.Date"
[65] "as.list.default" "as.list.environment"
[67] "as.list.factor" "as.list.function"
[69] "as.list.numeric_version" "as.list.POSIXct"
[71] "as.logical" "as.logical.factor"
[73] "as.matrix" "as.matrix.data.frame"
[75] "as.matrix.default" "as.matrix.noquote"
[77] "as.matrix.POSIXlt" "as.name"
[79] "as.null" "as.null.default"
[81] "as.numeric" "as.numeric_version"
[83] "as.octmode" "as.ordered"
[85] "as.package_version" "as.pairlist"
[87] "as.POSIXct" "as.POSIXct.date"
[89] "as.POSIXct.Date" "as.POSIXct.dates"
[91] "as.POSIXct.default" "as.POSIXct.numeric"
[93] "as.POSIXct.POSIXlt" "as.POSIXlt"
[95] "as.POSIXlt.character" "as.POSIXlt.date"
[97] "as.POSIXlt.Date" "as.POSIXlt.dates"
[99] "as.POSIXlt.default" "as.POSIXlt.factor"
[101] "as.POSIXlt.numeric" "as.POSIXlt.POSIXct"
[103] "as.qr" "as.raw"
[105] "as.single" "as.single.default"
[107] "as.symbol" "as.table"
[109] "as.table.default" "as.vector"
[111] "as.vector.factor" "asin"
[113] "asinh" "asNamespace"

9.5. VISIBILIDAD 89
[115] "asS3" "asS4"

[117] "assign"
www.editorialuc.es
9.4.3. Destrucción
El acumular muchos objetos en memoria no es deseable porque puede en-
lentecer la ejecución del programa, e incluso, producir errores por utilizar ob-
jetos que pueden tener el mismo nombre pero con valores diferentes. Por es-
to una buena técnica de programación es borrar los objetos que no vayan a
ser usados con posterioridad. R tiene una función que permite borrarlos. Con
rm() se pasan como argumento los objetos que se quieren borrar. Cuando se
desean borrar todos los objetos excepto las funciones, una función excelente
para ello es la función zap del paquete epicalc.
#---------------------------------------------------------------
zap()
#---------------------------------------------------------------
Ejemplo 9.18. Borre todos los objetos de su workspace.
> zap() # se borran todos excepto las funciones

> ls() # se comprueba que no ha quedado ninguno
character(0)
9.5. Visibilidad
Las variables creadas dentro de una función se dice que son locales: son
visibles dentro de la función y desaparecen al salir de ella.
Ejemplo 9.19. Declare la variable a con valor 77. Cree una función que en su
interior cambie el valor de a. Tras ejecutar esa función, ¿cambia el valor de a?
> a <- 77
> f <- function(x) {
+ a <- x
+ cat("El valor de a dentro de la función es", a, "\n")
+ aˆ3
+ }
>
> cat("El valor de a es", a, "\n")
El valor de a es 77
> f(2)
El valor de a dentro de la función es 2
[1] 8
> cat("El valor de a fuera de la función es", a, "\n")
El valor de a fuera de la función es 77
Las variables creadas fuera de las funciones son globales, y están dispo-
nibles también dentro de las funciones [146].
> a <- 77

> b <- 100

+ a <- x
+ cat("El valor de a dentro de la función es", a, "\n")
+ cat("El valor de b dentro de la función es", b, "\n")
+ a + b
+ }
>
> cat("El valor de a es", a, "y el valor de b es", b, "\n")
El valor de a es 77 y el valor de b es 100
> f(2)
El valor de a dentro de la función es 2
El valor de b dentro de la función es 100
[1] 102
> cat("El valor de a es", a, "y el valor de b es", b, "\n")
El valor de a es 77 y el valor de b es 100

tablas:
Función Acción
as.array() Fuerza a array
as.character() Fuerza a caracteres
as.complex() Fuerza a complejo
as.data.frame() Fuerza a data frame
as.double() Fuerza a Doble
as.factor() Fuerza a factor
as.list() Fuerza a lista
as.logical() Fuerza a lógico
as.matrix() Fuerza a matriz
as.numeric() Fuerza a numérico
as.raw() Fuerza a datos raw
as.ts() Fuerza a serie temporal
as.vector() Fuerza a vector
attr() Visualiza o crea un atributo
attributes() Visualiza o crea atributos
c() Concatena elementos
cbind() Junta objetos opor columnas
cat() Imprime en pantalla
class() Clase de un objeto
dim() Visualiza las dimensiones de un objeto
function() Crea una función
is.array() Comprueba si es un array
is.character() Comprueba si es un vector de caracteres
is.complex() Comprueba si es un vector complejo
is.data.frame() Comprueba si es un data frame

Función Acción
is.double() Comprueba si es un número ((double))
www.editorialuc.es
is.factor() Comprueba si es un factor
is.list() Comprueba si es una lista
is.logical() Comprueba si es un vector lógico
is.matrix() Comprueba si es una matriz
is.numeric() Comprueba si es un un vector numérico
is.raw() Comprueba si es un un vector de datos raw
is.ts() Comprueba si es una serie temporal
is.vector() Comprueba si es un vector
library() Carga un paquete
list() Crea listas
ls() Lista los objetos existentes en memoria
mode() Modo de almacenamiento
names() Presenta o asigna los nombres
numeric() Declara un objeto como numérico
objects() Lista los objetos en memoria
remove() Remueve (elimina) objetos de la memoria
rm() Remueve (elimina) objetos de la memoria
storage.mode() Modo de almacenamiento de un objeto
str() Estructura de un objeto
structure() estructura ((fina)) de un objeto
typeof() Declara el tipo de un objeto.
zap() Borra todas los objetos excepto las funciones
Tabla 9.7: Paquetes de R utilizadas en este capı́tulo
Función Acción
epicalc Funciones epidemiológicas con epicalc [136]
PROBLEMAS
Problema 1. Con la función ls.str() puede ver los objetos que tiene en el entorno
de trabajo. Después de ejecutar el código anterior, ¿cuantos objetos tiene en memoria?,
¿de qué tipo son?
Problema 2. Intente averiguar el resultado del siguiente código antes de ejecutarlo
(tomado de Wickham [148]).
f <- function(x) {
f <- function(x) {
f <- function(x) {
x ˆ 2
}
f(x) + 1
}
f(x) + 2
}
f(10)

Problema 3. ¿Qué longitud cree que tendrá la función f() que acaba de crear?
Compruébelo.
Problema 4. Cree la función g() más sencilla que la anterior, con una única lı́nea
de código. ¿Qué longitud tendrá?
Problema 5. ¿Se pueden comparar objetos que no sean listas o vectores atómicos?
Compruebe si es posible conocer si la función b() es mayor que la función g().
Problema 6. ¿Como puede convertir la cadena "2.718281828459" en un núme-
ro? (es el valor del número e, base de los logaritmos neperianos).

www.editorialuc.es
Capı́tulo 10
Vectores
La estructura básica de datos en R es el vector [148]. R tiene una gran va-

riedad de estructuras, entre las que destacan los vectores, que, de acuerdo con
Matloff1 , son el corazón de R [146].
Siguiendo a Wickham [148], los objetos en R pueden ser clasificados según
dos aspectos: dimensionalidad y homogeneidad, como se refleja en la siguiente
Figura 10.1.
Figura 10.1: Clasificación de las estructuras más frecuentemente empleadas en R. En

color naranja las homogéneas y en color azul las heterogéneas.
Estructuras en R
Una Dos Más de dos

dimensión dimensiones dimensiones
Vectores data
listas matrices arrays
atómicos frames
Los escalares (objetos con 0 dimensiones) no existen en R.
1It’s hard to imagine R code, or even an interactive R session, that doesn’t involve vectors.
93
94 CAPÍTULO 10. VECTORES
10.1. Concepto
Los vectores son colecciones ordenadas de objetos, todos ellos del mismo
tipo [94]. Los vectores son el tipo de objetos más utilizados en R. En la mayorı́a
de las ocasiones se crean con la función c().
Las caracterı́sticas de los elementos que los forman (números, valores lógi-
cos, cadenas de caracteres, etc.) determinan los diferentes tipos de vectores.
Hay dos tipos fundamentales: vectores y listas2 . Los componentes de los vec-
tores son todos del mismo tipo, mientras que los de las listas no.
Todos ellos tienen tres propiedades comunes: longitud, tipo y atributos que
se exploran con las funciones length(), typeof() y attributes(), res-
pectivamente.
10.1.1. Vectores atómicos

Son un conjunto de elementos del mismo tipo. Ası́, el vector v está formado
por n elementos:
v := {x1 , x2 , ..., xn }
Hay seis tipos: enteros, numéricos, lógicos, caracteres, complejos y crudos

(los dos últimos se utilizan muy poco). Se comprueban con is.integer(),
is.double(), is.logical(), is.character().
Se puede comprobar que un vector es atómico con la función is.atomic().
En ocasiones falta algún elemento de un vector. Esta caracterı́stica se debe
especificar en R con ((NA)), que es un vector lógico de longitud 1.
10.1.2. Listas
Los elementos de una lista pueden ser de diferentes tipos, como veremos
en un próximo capı́tulo.
Para comprobar si un objeto es una lista se debe utilizar is.list().
Para ir explicando los diferentes vectores nos serviremos de un pequeño
ejemplo en el que se han recogido diferentes datos antropométricos de diez
familias3 (Tabla 10.1).
Del sujeto número 6 no se dispone de ningún dato antropométrico porque
falleció cuando tenı́a dos años de edad. Del sujeto 15 no se dispone de la talla
y del sujeto 18 no se dispone del perı́metro de la cintura.
A lo largo de este capı́tulo iremos creando vectores con los datos de esta
tabla, cada uno de ellos con los datos de cada una de las variables registradas;
cuando no está disponible un dato se teclea NA (not available).
10.2. Creación de vectores

Los vectores se crean de diferentes maneras, fundamentalmente mediante
concatenaciones, repeticiones y secuencias.
2 Vectors come in two flavours: atomic vectors and lists [148]

3 Se trata de 10 familias ficticias que el lector deberá ir tecleando ((para hacer manos)).

10.2. CREACIÓN DE VECTORES 95
Tabla 10.1: Datos antropométricos de diez familias hipotéticas
www.editorialuc.es
id family relative nom age alive sex weight height waist
(yr) (kg) (cm) (cm)
1 F1 padre Pedro 42 TRUE M 78,0 173,0 86,2
2 F1 madre Marı́a 39 TRUE F 57,3 164,5 66,4
3 F1 hijo1 Juan 13 TRUE M 42,7 156,3 60,1
4 F1 hijo2 Lucı́a 12 TRUE F 38,3 147,6 53,2
5 F1 hijo3 Marcos 9 TRUE M 27,7 130,2 54,6
6 F1 hijo4 Miguel FALSE M
7 F1 hijo5 Clara 3 TRUE F 14,6 95,7 48,3
8 F2 padre Luis 37 TRUE M 86,9 172,5 93,0
9 F2 madre Marta 34 TRUE F 62,5 161,6 68,5
10 F2 hijo1 Marta 7 TRUE F 23,0 124,0 48,0
11 F3 padre Martı́n 28 TRUE M 76,3 178,0 77,0
12 F3 madre Carmen 26 TRUE F 58,0 162,0 64,0
13 F3 hijo1 FALSE F
14 F4 padre Antón 42 TRUE M 78,2 173,0 86,2
15 F4 madre Mónica 42 TRUE F 67,0 159,0 77,0
16 F4 hijo1 Aylin 10 TRUE F 28,6 50,5
17 F5 padre Paco 38 TRUE M 82,0 176,0 85,0
18 F5 madre Paz 37 TRUE F 61,5 159,5 66,0
19 F5 hijo1 Dolores 6 TRUE F 18,7 114,0
20 F5 hijo2 Gorka 4 TRUE M 16,3 102,6 44,0
21 F5 hijo3 José 4 TRUE M 16,5 101,3 45.2
22 F6 padre Alberto 36 TRUE M 82,0 176,0 45,0
23 F6 madre Andrea 32 TRUE F 61,5 159,0 66,0
24 F6 hijo1 Juan 3 TRUE M 13,2 98.7 44,0
25 F6 hijo2 Paco 3 TRUE M 13,8 99.6 45,0
26 F6 hijo3 José 3 TRUE M 13,6 95.0 45,5
27 F7 madre Marina 32 TRUE F 61,4 169,0 76,0
28 F7 hijo1 Juan 1 TRUE M 8,7 74.0 43.2
29 F7 hijo2 Pablo 1 TRUE M 9,3 75.5 44.0
30 F8 padre Gabriel 42 TRUE M 78.8 173.8 85.2
31 F8 madre Marı́a 39 TRUE F 57.8 164.8 67.4
32 F8 hijo1 Juan 13 TRUE M 42.9 156.8 60.3
33 F8 hijo2 Leonor 12 TRUE F 38.8 147.8 53.8
34 F9 padre Pepe 37 TRUE M 81.0 174.0 89.5
35 F9 madre Gloria 34 TRUE F 56.7 165.5 70.5
36 F9 hijo1 Ana 16 TRUE F 52.0 164.0 56.0
37 F9 hijo2 Marina 14 TRUE F 49.5 153.0 54.0
38 F9 hijo3 Pilar 14 TRUE F 48.0 152.0 53.3
39 F9 hijo4 Carmen 7 TRUE F 34.0 135.0 62.2
40 F10 padre Emil 29 TRUE M 88.9 170.5 88.2
41 F10 madre Isis 22 TRUE F 70.3 160.3 69.0
42 F10 hijo1 Chema 1 TRUE M 10.5 75.0 49.5

10.2.1. Concatenación
La forma más simple de crear un vector es concatenar todos sus elementos
utilizando la función c().
#---------------------------------------------------------------
c(..., recursive = FALSE)
#---------------------------------------------------------------
Ejemplo 10.1. Cree el vector weight con los pesos (kg) de las familias de la
tabla 10.1.
> weight <- c(78.0, 57.3, 42.7, 38.3, 27.7,

+ NA, 14.6, 86.9, 62.5, 23.0,
+ 76.3, 58.0, NA, 78.2, 67.0,
+ 28.6, 82.0, 61.5, 18.7, 16.3,
+ 16.5, 82.0, 61.5, 13.2, 13.8,
+ 13.6, 61.4, 8.7, 9.3, 78.8,
+ 57.8, 42.9, 38.8, 81.0, 56.7,
+ 52.0, 49.5, 48.0, 34.0, 88.9,
+ 70.3, 10.5)
> weight # presenta en la consola su contenido
[1] 78.0 57.3 42.7 38.3 27.7 NA 14.6 86.9 62.5 23.0 76.3 58.0
----------------------- lı́neas omitidas -----------------------
[37] 49.5 48.0 34.0 88.9 70.3 10.5
Es posible crear un vector utilizando la función scan(), pero se suele uti-

lizar muy poco. También es posible crear un vector con la función assign(),
que también se usa poco.
#---------------------------------------------------------------
scan(file = "", what = double(), nmax = -1, n = -1, sep = "",
quote = if(identical(sep, "\n")) "" else "’\"", dec = ".",
skip = 0, nlines = 0, na.strings = "NA",
flush = FALSE, fill = FALSE, strip.white = FALSE,
quiet = FALSE, blank.lines.skip = TRUE, multi.line = TRUE,
comment.char = "", allowEscapes = FALSE,
fileEncoding = "", encoding = "unknown", text,
skipNul = FALSE)
assign(x, value, pos = -1, envir = as.environment(pos),

inherits = FALSE, immediate = TRUE)
#---------------------------------------------------------------
Ejemplo 10.2. Cree el vector weight empleando la función assign() con

los datos de la misma tabla.
> assign(’height’, c(173.0, 164.5, 156.3, 147.6, 130.2,

+ NA, 97.5, 172.5, 161.6, 124.0,
+ 178.0, 162.0, NA, 173.0, 159.0,
+ NA, 176.0, 159.5, 114.0, 102.6,
+ 101.3, 176.0, 159.0, 98.7, 99.6,
+ 95.0, 169.0, 74.0, 75.5, 173.8,

10.2. CREACIÓN DE VECTORES 97
+ 164.8, 156.8, 147.8, 174.0, 165.5,

+ 164.0, 153.0, 152.0, 135.0, 170.5,
www.editorialuc.es
+ 160.3, 75.0))
> height # presenta en la consola su contenido
[1] 173.0 164.5 156.3 147.6 130.2 NA 97.5 172.5 161.6 124.0
----------------------- lı́neas omitidas -----------------------
[31] 164.8 156.8 147.8 174.0 165.5 164.0 153.0 152.0 135.0 170.5
[41] 160.3 75.0
10.2.2. Secuencias
En estadı́stica se utilizan con mucha frecuencia series de números. Estas
series o secuencias se pueden crear con la función seq() que admite varios
parámetros: from = x (x es el valor de inicio, por defecto es igual a 1), to =
y (y es el valor final, por defecto es igual a 1), by = z (z es el incremento de un
valor a otro, por defecto es igual a 1), length.out (es la longitud del vector),
along.with = vector (genera una secuencia de números naturales, desde
1 hasta la longitud del vector especificado. En este caso este parámetro debe
ser el único especificado).
#---------------------------------------------------------------
seq(from = 1, to = 1, by = ((to - from)/(length.out - 1)),
length.out = NULL, along.with = NULL, ...)
#---------------------------------------------------------------
Si se desea una secuencia: seq(from = 1, to = 15, by = 1) crea una

secuencia de los 15 primeros números naturales.
> seq(from = 1, to = 15, by = 1)
[1] 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
Una forma más sencilla es seq(15) y más sencilla aún es utilizando el

operador inicio:fin
> seq(15)
[1] 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
> 1:15
[1] 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
Ejemplo 10.3. Cree un vector numérico llamado id, con los primeros 42
números naturales, para identificar biunı́vocamente y sin duplicados a cada
uno de los individuos de la Tabla 10.1.
> (id <- 1:42)
[1] 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
[21] 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40
[41] 41 42
Si desea una secuencia cada ((x)) números deberı́amos utilizar la siguiente

orden seq(inicio, fin, x), ası́ obtendremos la secuencia de los números
a partir de inicio hasta fin, de x en x.
Ejemplo 10.4. Obtenga los números impares existentes entre el número 21 y

el 40.

> seq(21, 40, 2)

[1] 21 23 25 27 29 31 33 35 37 39
Si pretende crear una secuencia repartida entre dos valores determinados

utilice seq(from = inicio, to = fin, length = x). R se encarga de
calcular los x números repartidos entre el número inicial y el número final.
Ejemplo 10.5. Calcule 13 números repartidos entre el 1 y el 500.
> seq(from = 1, to = 500, length = 13)

[1] 1.00000 42.58333 84.16667 125.75000 167.33333
[6] 208.91667 250.50000 292.08333 333.66667 375.25000
[11] 416.83333 458.41667 500.00000
Cuando quiere una secuencia de números naturales de una longitud igual

a la de otro vector utilice: seq(along = vector), que crea una secuencia
desde 1 hasta un número igual a la longitud de un vector especificado.
Ejemplo 10.6. Cree una secuencia de números naturales de longitud igual a

la del vector weight.
> seq(along = weight)

[1] 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
[21] 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40
[41] 41 42
10.2.3. Repeticiones
Otra función relacionada con la generación de números, y muy utilizada,
es rep(), que permite replicar un objeto (o cada uno de sus elementos) un
determinado número de veces.
#---------------------------------------------------------------
rep(x, ...)
#---------------------------------------------------------------
> rep(7, times = 10) # repite 10 veces el número 7

[1] 7 7 7 7 7 7 7 7 7 7
> rep(1:3, times = 4) # repite 4 veces el vector 1:3
[1] 1 2 3 1 2 3 1 2 3 1 2 3
> rep(1:3, each = 4) # repite 4 veces cada elemento del vector
[1] 1 1 1 1 2 2 2 2 3 3 3 3
Ejemplo 10.7. Cree el vector family utilizando las funciones c() y rep().
> family <- rep(paste(’F’, 1:10, sep=’’),

+ c(7, 3, 3, 3, 5, 5, 3, 4, 6, 3))
> family
[1] "F1" "F1" "F1" "F1" "F1" "F1" "F1" "F2" "F2" "F2"
----------------------- lı́neas omitidas -----------------------
[31] "F8" "F8" "F8" "F9" "F9" "F9" "F9" "F9" "F9" "F10"
[41] "F10" "F10"

10.3. TIPOS DE VECTORES 99
Otra forma de generar repeticiones es concatenando vectores (o partes de

ellos) como se hace en el siguiente ejemplo:
www.editorialuc.es
Ejemplo 10.8. Cree el vector relative utilizando la función c() y con ayu-
da de un vector auxiliar formado por c(’padre’, ’madre’, ’hijo1’,
’hijo2’, ’hijo3’, ’hijo4’, ’hijo5’).
> x <- c(’padre’, ’madre’,

+ ’hijo1’, ’hijo2’, ’hijo3’, ’hijo4’, ’hijo5’)
> relative <- c(x, x[1:3], x[1:3], x[1:3], x[1:5],
+ x[1:5], x[2:4], x[1:4], x[1:6], x[1:3])
> relative
[1] "padre" "madre" "hijo1" "hijo2" "hijo3" "hijo4" "hijo5"
----------------------- lı́neas omitidas -----------------------
[36] "hijo1" "hijo2" "hijo3" "hijo4" "padre" "madre" "hijo1"
> rm(x)
10.3. Tipos de vectores

Fundamentalmente existen cuatro tipos de vectores: numéricos, de caracte-
res, lógicos y listas.
10.3.1. Lógicos
Están compuestos por elementos que solo pueden ser TRUE o FALSE.
Ejemplo 10.9. Siguiendo con el ejemplo de la familia, supongamos que se

quiere registrar si está vivo cada uno de sus miembros, de forma que para
los vivos será TRUE y para los muertos FALSE.
> alive <- c( rep(TRUE, 5), FALSE, rep(TRUE, 6),

+ FALSE, rep(TRUE, 29))
> alive
[1] TRUE TRUE TRUE TRUE TRUE FALSE TRUE TRUE TRUE TRUE
----------------------- lı́neas omitidas -----------------------
[31] TRUE TRUE TRUE TRUE TRUE TRUE TRUE TRUE TRUE TRUE
[41] TRUE TRUE
Cuando se crean con la función vector(), se crean por defecto con FALSE:
#---------------------------------------------------------------
vector(mode = "logical", length = 0)
as.vector(x, mode = "any")
is.vector(x, mode = "any")
#---------------------------------------------------------------
> (x <- vector(mode = ’logical’, length = 10))

[1] FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE
[10] FALSE
> rm(x)
Otra función similar es logical():

#---------------------------------------------------------------
logical(length = 0)
as.logical(x, ...)
is.logical(x)
#---------------------------------------------------------------
Ejemplo 10.10. Cree un vector lógico de 10 elementos de longitud.
> logical(10)
[1] FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE
[10] FALSE
10.3.2. Numéricos
Los vectores numéricos son muy utilizados en estadı́stica. Se pueden dis-
tinguir tres subtipos según el tipo de número de sus elementos:
Enteros
Son vectores en los que todos sus elementos son números enteros (positivos
y negativos).
Ejemplo 10.11. Cree el vector age con las edades de los 42 sujetos de las
familias recogidos en la Tabla 10.1.
> age <- c(42, 39, 13, 12, 9, NA, 3, 37, 34, 7,
+ 28, 26, NA, 42, 42, 10, 38, 37, 6, 4,
+ 4, 36, 32, 3, 3, 3, 32, 1, 1, 42,
+ 39, 13, 12, 37, 34, 16, 14, 14, 7, 29,
+ 22, 1)
> age
[1] 42 39 13 12 9 NA 3 37 34 7 28 26 NA 42 42 10 38 37 6 4
[21] 4 36 32 3 3 3 32 1 1 42 39 13 12 37 34 16 14 14 7 29
[41] 22 1
Se pueden crear con la función vector(), que pone todos sus elementos
igual a 0, o con la función integer():
#---------------------------------------------------------------
integer(length = 0)
as.integer(x, ...)
is.integer(x)
#---------------------------------------------------------------
Ejemplo 10.12. Cree un vector de enteros de longitud 10.
> (x <- vector(mode = ’integer’, length = 10))

[1] 0 0 0 0 0 0 0 0 0 0
> mode(x) # modo del vector x
[1] "numeric"
> class(x) # clase del vector x

[1] "integer"
> (x <- integer(10)) # similar a vector()
www.editorialuc.es
[1] 0 0 0 0 0 0 0 0 0 0
Reales
Los números reales abarcan a los enteros, racionales e irracionales. Se al-
macenan en memoria con doble precisión (15 decimales). Por ejemplo el peso
y la talla se han almacenado como números reales. Se pueden crear con las
funciones c(), vector(mode = "numeric") y double().
#---------------------------------------------------------------
double(length = 0)
as.double(x, ...)
is.double(x)
#---------------------------------------------------------------
> (x <- vector(mode=’numeric’, length=10))

[1] 0 0 0 0 0 0 0 0 0 0
> mode(x)
[1] "numeric"
> class(x)
[1] "numeric"
> (x <- double(10))
[1] 0 0 0 0 0 0 0 0 0 0
> rm(x)
Ejemplo 10.13. Imprima en pantalla los pesos de las personas y diga de

qué tipo es este vector.
> (weight)
[1] 78.0 57.3 42.7 38.3 27.7 NA 14.6 86.9 62.5 23.0 76.3 58.0
----------------------- lı́neas omitidas -----------------------
[37] 49.5 48.0 34.0 88.9 70.3 10.5
> mode(weight)
[1] "numeric"
> class(weight)
[1] "numeric"
Complejos
Son los números que tienen una parte real y otra imaginaria. Por ejemplo,
3+2.5i. El primer componente es la parte real y se trata de un número real. La
segunda parte está compuesta por √ un número real y adyacente a él, sin ningún
espacio intermedio, la letra i (i = −1). Este tipo de números no los vamos a
utilizar en estadı́stica.
Por ejemplo, cuando queremos obtener raı́ces cuadradas de números nega-
tivos obtenemos un mensaje de aviso indicándonos que el resultado no es un
número (NaN), mientras que si le escribimos como número complejo, se obtiene
la solución correcta.

> sqrt(-4)
[1] NaN
Warning message:
In sqrt(-4) : Se han producido NaNs
> sqrt(-4 + 0i)
[1] 0+2i
También se puede crear con la función vector() y con la función complex(),

por ejemplo:
#---------------------------------------------------------------
complex(length.out = 0, real = numeric(), imaginary = numeric(),
modulus = 1, argument = 0)
as.complex(x, ...)
is.complex(x)
#---------------------------------------------------------------
Ejemplo 10.14. Cree un vector de 10 números complejos.
> (x <- vector(mode = ’complex’, length = 10))

[1] 0+0i 0+0i 0+0i 0+0i 0+0i 0+0i 0+0i 0+0i 0+0i 0+0i
> mode(x)
[1] "complex"
> class(x)
[1] "complex"
> (x <- complex(10))
[1] 0+0i 0+0i 0+0i 0+0i 0+0i 0+0i 0+0i 0+0i 0+0i 0+0i
Hay una serie de funciones para manejar números complejos: Re(), Im(),
Mod(), Arg(), Conj(). Aunque ponemos un ejemplo de su uso, no las utili-
zaremos en el trabajo habitual con R.
Ejemplo 10.15. Aplique estas últimas cinco funciones con el número com-
plejo 3 + 4i.
> z <- 3 + 4i # número complejo

> Re(z) # parte real
[1] 3
> Im(z) # parte imaginaria
[1] 4
> Arg(z) # argumento
[1] 0.9272952
> Conj(z) # conjugado
[1] 3-4i
10.3.3. Cadena
Son vectores en los que cada uno de sus elementos son cadenas de caracte-
res. Siempre deben ir entrecomillados.
Ejemplo 10.16. Cree el vector nom con los nombres de los miembros de las
familias de la Tabla 10.1.

> nom <- c(’Pedro’, ’Marı́a’, ’Juan’, ’Lucı́a’, ’Marcos’,

+ ’Miguel’, ’Clara’, ’Luis’, ’Marta’, ’Marta’,
www.editorialuc.es
+ ’Martı́n’, ’Carmen’, NA, ’Antón’, ’Mónica’,
+ ’Aylı́n’, ’Paco’, ’Paz’, ’Dolores’, ’Gorka’,
+ ’José’, ’Alberto’, ’Andrea’, ’Juan’, ’Paco’,
+ ’José’, ’Marina’, ’Juan’, ’Pablo’, ’Gabriel’,
+ ’Marı́a’, ’Juan’, ’Leonor’, ’Pepe’, ’Gloria’,
+ ’Ana’, ’Marina’, ’Pilar’, ’Carmen’, ’Emil’,
+ ’Isis’, ’Chema’)
> nom
[1] "Pedro" "Marı́a" "Juan" "Lucı́a" "Marcos" "Miguel"
----------------------- lı́neas omitidas -----------------------
[37] "Marina" "Pilar" "Carmen" "Emil" "Isis" "Chema"
Ejemplo 10.17. Cree el vector sex correspondiente a los miembros de esas

familias.
> sex <- c(’M’, ’F’, ’M’, ’F’, ’M’,

+ ’M’, ’F’, ’M’, ’F’, ’F’,
+ ’M’, ’F’, ’F’, ’M’, ’F’,
+ ’F’, ’M’, ’F’, ’F’, ’M’,
+ ’M’, ’M’, ’F’, ’M’, ’M’,
+ ’M’, ’F’, ’M’, ’M’, ’M’,
+ ’F’, ’M’, ’F’, ’M’, ’F’,
+ ’F’, ’F’, ’F’, ’F’, ’M’,
+ ’F’, ’M’)
> sex
[1] "M" "F" "M" "F" "M" "M" "F" "M" "F" "F" "M" "F" "F" "M" "F"
[16] "F" "M" "F" "F" "M" "M" "M" "F" "M" "M" "M" "F" "M" "M" "M"
[31] "F" "M" "F" "M" "F" "F" "F" "F" "F" "M" "F" "M"
10.3.4. Listas
Se trata de un tipo especial de vectores en los que todos sus elementos no
tienen por qué ser del mismo tipo. Se utilizan mucho para presentar los resul-
tados de las funciones. Se crean con la función list().
#---------------------------------------------------------------
list(...)
#---------------------------------------------------------------
Ejemplo 10.18. Cree una lista que contenga un vector numérico, un vector
de caracteres, un vector lógico, una matriz y un data frame.
> x <- list(Numero = 1:10,

+ Cadena = c(’Carmen’),
+ Logico = c(TRUE, FALSE),
+ Matriz = matrix(1:12, nrow = 3),
+ DF = data.frame(cbind(x = 1:12,
+ y = rnorm(12),
+ z = factor(c(1, 1, 1, 2, 2,
+ 1, 2, 2, 1, 1,

+ 2, 2)))))
> class(x)
[1] "list"
> x
$Numero
[1] 1 2 3 4 5 6 7 8 9 10
$Cadena
[1] "Carmen"
$Logico
[1] TRUE FALSE
$Matriz
[,1] [,2] [,3] [,4]
[1,] 1 4 7 10
[2,] 2 5 8 11
[3,] 3 6 9 12
$DF
x y z
1 1 -0.30005219 1
2 2 -1.06524125 1
3 3 -0.38313515 1
4 4 -0.84972448 2
5 5 -0.11528650 2
6 6 0.08039173 1
7 7 0.85326327 2
8 8 -0.96125588 2
9 9 -0.09634481 1
10 10 -0.14138306 1
11 11 -0.54458848 2
12 12 0.88333289 2
Más adelante se irán viendo ejemplos.
10.3.5. Elementos especiales

Cuando se realizan cálculos, en un vector pueden aparecer una serie de ele-
mentos especiales, como son +∞ y −∞, es decir que R maneja perfectamente
el infinito:
> 4.2/0 # + infinito

[1] Inf
> -7/0 # - infinito
[1] -Inf
> exp(-Inf) # 2.71828ˆ(-Inf)
[1] 0
> 0/Inf
[1] 0
En otras ocasiones los resultados de los cálculos son indeterminados (ecua-

ción 1), el sistema R los representa como NaN (not a number):

> Inf - Inf

[1] NaN
www.editorialuc.es
> Inf / Inf
[1] NaN
> Inf * 0
[1] NaN
> 0 * Inf
[1] NaN
> 0 / 0
[1] NaN
Existen 7 casos de indeterminaciones [164–166], de éstos, presentados en la

ecuación 10.1, R resuelve perfectamente los cuatro primeros (de la ecuación 1)
como ya hemos visto, pero falla en los tres últimos (∞0 , ∞ , 00 ), porque ofrece
un resultado que no es correcto:
∞ 0
∞ − ∞, , 0 × ∞, , ∞0 , 1∞ , 00 (10.1)
∞ 0
# indeterminaciones incorrectas
> Infˆ0
[1] 1
> 1Înf
[1] 1
> 0ˆ0
[1] 1
Otro valor que maneja el sistema R y que aparece en muchas ocasiones es

NA (not available), es el valor que se utiliza para los datos ausentes (missing).
Ejemplo 10.19. Cree el vector waist con los datos de la Tabla 10.1.
Se observa que en tres sujetos, id = 6, 13 y 19, el perı́metro de la cintura no
se registró. Deberemos teclear NA, ya que son datos ausentes no disponibles
(missing).
> waist <- c(86.2, 66.4, 60.1, 53.2, 54.6,

+ NA, 48.3, 93.0, 68.5, 48.0,
+ 77.0, 64.0, NA, 86.2, 77.0,
+ 50.5, 85.0, 66.0, NA, 44.0,
+ 45.2, 45.0, 66.0, 44.0, 45.0,
+ 45.5, 76.0, 43.2, 44.0, 85.2,
+ 67.4, 60.3, 53.8, 89.5, 70.5,
+ 56.0, 54.0, 53.3, 62.2, 88.2,
+ 69.0, 49.5)
> waist
[1] 86.2 66.4 60.1 53.2 54.6 NA 48.3 93.0 68.5 48.0 77.0 64.0
[13] NA 86.2 77.0 50.5 85.0 66.0 NA 44.0 45.2 45.0 66.0 44.0
[25] 45.0 45.5 76.0 43.2 44.0 85.2 67.4 60.3 53.8 89.5 70.5 56.0
[37] 54.0 53.3 62.2 88.2 69.0 49.5

10.4. Operaciones con vectores

10.4.1. Poner nombres
Se puede asignar nombres a los vectores de tres maneras: (1) cuando se
crean, (2) con la función names y (3) haciendo una copia y empleando la fun-
ción setNames().
> (x <- c(a = 5, b = 7, c = 9)) # primera

> x <- c(5, 7, 9); names(x) <- c(’a’, ’b’, ’c’); x # segunda
> (x <- setNames(c(5, 7, 9), c(’a’, ’b’, ’c’)) ) # tercera
10.4.2. En vectores numéricos

Para que se puedan sumar dos vectores deben tener éstos la misma longi-
tud. Si es ası́, R suma los elementos que están en la misma posición:
> x <- 1:4

> y <- 4:1
> x + y
[1] 5 5 5 5
Ası́, suma el elemento que está en la primera posición en x (x[1] = 1) con

el elemento de y que está en primera posición (y[1] = 4), después suma el
elemento que está en segunda posición en cada uno de los dos vectores (2+3 =
5) y ası́ hace con el resto. Cuando uno de los vectores es más corto, lo recicla
tantas veces como sea necesario hasta que consiga un vector de longitud igual
o mayor a la del otro vector. Este reciclado puede ser completo (el vector corto
se transforma en otro de igual longitud que la del vector largo):
> x <- 1:10

> y <- 1:5
> x + y
[1] 2 4 6 8 10 7 9 11 13 15
En otras ocasiones el reciclado es incompleto (el vector reciclado se trans-

forma en otro de mayor longitud que el vector largo, y entonces utiliza los
elementos necesarios, de forma que algunos elementos se pierden y entonces
R nos lo comunica con un mensaje de aviso (warning).
> x <- 1:10

> y <- 1:6
> x + y
[1] 2 4 6 8 10 12 8 10 12 14
Warning message:
In x + y :
longitud de objeto mayor no es múltiplo de la longitud de uno menor
> rm(x, y)
Este mismo comportamiento sucede con las otras operaciones matemáticas:
Ejemplo 10.20. Calcule la relación ((cintura / altura)) con los datos de las
personas de la Tabla 10.1.

10.4. OPERACIONES CON VECTORES 107
> waist / height

[1] 0.4982659 0.4036474 0.3845170 0.3604336 0.4193548 NA
www.editorialuc.es
[7] 0.4953846 0.5391304 0.4238861 0.3870968 0.4325843 0.3950617
[13] NA 0.4982659 0.4842767 NA 0.4829545 0.4137931
[19] NA 0.4288499 0.4461994 0.2556818 0.4150943 0.4457953
[25] 0.4518072 0.4789474 0.4497041 0.5837838 0.5827815 0.4902186
[31] 0.4089806 0.3845663 0.3640054 0.5143678 0.4259819 0.3414634
[37] 0.3529412 0.3506579 0.4607407 0.5173021 0.4304429 0.6600000
10.4.3. En vectores de caracteres

No se pueden utilizar los operadores de suma, resta, multiplicación, etc.
porque no se tratan de vectores numéricos.
> a <- c(’bici’, ’coche’, ’moto’)
> b <- c(’Juan’, ’Pedro’, ’Marı́a’)
> a + b
Error in a + b : argumento no-numérico para operador binario
Aquı́ se puede utilizar la función paste(), que se comporta de una manera

similar a como funciona la suma de dos vectores numéricos, es decir, une los
elementos que están en la misma posición en los dos vectores en una única
cadena con un espacio de separación entre ellos.
> paste(a, b)
[1] "bici Juan" "coche Pedro" "moto Marı́a"
Cuando uno de los vectores es más corto, le recicla y utiliza sus elementos
de forma completa (si la longitud de un vector es múltiplo de la longitud del
otro) o incompleta (cuando la longitud de uno no es múltiplo de la del otro).
> c <- c(’chico’, ’chica’)
> paste(a, c) # reciclado incompleto
[1] "bici chico" "coche chica" "moto chico"
> rm(a, b, c)
Se puede utilizar esto para crear nombres de variables, ası́ para crear 30
variables llamadas var1, var2, ..., var30, se utiliza el siguiente código, en el que
se ha pasado como tercer parámetro a la función paste() la indicación de que
no deje ningún espacio con sep = ’’:
> paste(’var’, 1:30, sep=’’)
[1] "var1" "var2" "var3" "var4" "var5" "var6" "var7"
[29] "var29" "var30"
Hay otras funciones muy interesantes que se pueden aplicar a cadenas de

caracteres: substr(), nchar(), strsplit(), toupper() y tolower().
La función nchar() cuenta el número de caracteres de una cadena.
#---------------------------------------------------------------
nchar(x, type = "chars", allowNA = FALSE, keepNA = NA)
#---------------------------------------------------------------

Ejemplo 10.21. ¿Cuantos caracteres hay en el tercer párrafo del prólogo?
> w <- "La investigación, uno de los principales motores del

+ desarrollo de un paı́s, solo tiene éxito cuando se hace
+ adecuadamente, es decir, cuando siguen los pasos del Método
+ Cientı́fico, ya que si transcurre por un camino confundido, o
+ erróneo, no llegará a alcanzar el fin pretendido. Por tanto,
+ los investigadores necesitan formación en Metodologı́a de
+ Investigación."
> nchar(w)
[1] 361
La función substr() extrae una subcadena de una cadena de caracteres,

empezando en una posición y acabando en otra.
#---------------------------------------------------------------
substr(x, start, stop)
substr(x, start, stop) <- value
#---------------------------------------------------------------
Ejemplo 10.22. Extraiga una subcadena desde la posición 162 hasta la 178.
> substr(w, 162, 178)

[1] "Método Cientı́fico"
La función strsplit() divide una cadena en subcadenas según un deter-

minado criterio.
#---------------------------------------------------------------
strsplit(x, split, fixed = FALSE, perl = FALSE, useBytes = FALSE)
#---------------------------------------------------------------
Ejemplo 10.23. Divida la cadena anterior en palabras y cuente el número de

palabras.
> (x <- strsplit(w, ’ ’))

[[1]]
[1] "La" "investigación," "uno"
[4] "de" "los" "principales"
[7] "motores" "del" "desarrollo"
[10] "de" "un" "paı́s,"
[13] "solo" "tiene" "éxito"
[16] "cuando" "se" "hace"
[19] "adecuadamente," "es" "decir,"
[22] "cuando" "siguen" "los"
[25] "pasos" "del" "Método"
[28] "Cientı́fico," "ya" "que"
[31] "si" "transcurre" "por"
[34] "un" "camino" "confundido,"
[37] "o" "erróneo," "no"
[40] "llegará" "a" "alcanzar"
[43] "el" "fin" "pretendido."
[46] "Por" "tanto," "los"

10.5. MANIPULACIÓN DE VECTORES 109
[49] "investigadores" "necesitan" "formación"

[52] "en" "Metodologı́a" "de"
www.editorialuc.es
[55] "Investigación."
> length(unlist(x))
[1] 55
Ejemplo 10.24. ¿Qué letra, vocal o consonante aparece con mayor frecuen-
cia?
> table(strsplit(w, ’’))
, . a á c C d e é f g h i I ı́ l L m M n
54 8 2 26 1 15 1 18 35 2 4 6 1 22 1 3 14 1 4 2 29
o ó p P q r s t u v x y z
32 4 6 1 1 17 20 15 10 3 1 1 1
La letra ((e)).
Ejemplo 10.25. Ponga el tı́tulo de esta obra en mayúsculas.
> x <- ’El programa R, herramienta clave en investigación. I Lenguaje R’

> toupper(x)
[1] "EL PROGRAMA R, HERRAMIENTA CLAVE EN INVESTIGACIÓN. I LENGUAJE R"
10.5. Manipulación de vectores

Cada elemento de un vector tiene tres caracterı́sticas (posición, valor y nom-
bre) que pueden ser utilizadas para extraerle o manipularle (Tabla 10.2).
Tabla 10.2: Extracción y manipulación de los elementos de un vector
Operación Resultado
x[1] Extrae el primer elemento
x[length(x)] Extrae el último
x[i] Extrae el elemento que está en la posición i
x[-i] Extrae todos menos el elemento en posición i
x[c(4, 7, 8)] Extrae los elementos en posición 4, 7 y 8
x[-c(4, 7, 8)] Extrae todos menos los elementos en posición
4, 7 y 8
x[’cadena’] Extrae el elemento cuyo nombre coincide con
’cadena’
x[i] <- 420 Cambia el valor del elemento en posición i
por 420
x[c(3,7)] <- c(1, 2) Los elementos en posición 3 y 7 cambian a 1
y2
which(x >50.1) Pregunta qué elemento cumple una condi-
ción

10.5.1. Extracción de elementos (subsetting)

La posición de un elemento especificado se determina por el número que
está entre corchetes. Ası́ waist[1] corresponde al primer elemento del vector
waist, sabemos que corresponde a Pedro y su valor es 86.2 cm. waist[4:12]
extrae (presenta en pantalla) el valor del perı́metro de la cintura de los sujetos
comprendidos entre el cuarto puesto (Lucı́a) y el duodécimo (Carmen). Cuan-
do se pone un signo negativo en el ı́ndice se eliminan esos elementos y queda
el resto, ası́, waist[-(1:40)] solo deja los 2 últimos sujetos.
> waist[1]
[1] 86.2
> waist[4:12]
[1] 53.2 54.6 NA 48.3 93.0 68.5 48.0 77.0 64.0
> waist[-(1:40)]
[1] 69.0 49.5
Cuando el ı́ndice es superior a la longitud del vector, devuelve NA, por eso
waist[min(waist)] y waist[max(waist)] devuelven NA.
> waist[max(waist)]
[1] NA
> waist[min(waist)]
[1] NA
Con la función which() podemos preguntar por alguna caracterı́stica o

condición.
#---------------------------------------------------------------
which(x, arr.ind = FALSE, useNames = TRUE)
#---------------------------------------------------------------
Ejemplo 10.26. ¿Quiénes tienen un perı́metro de la cintura menor de 50 cm?

> which(waist < 50)
[1] 7 10 20 21 22 24 25 26 28 29 42
Estas posiciones permiten extraer el valor que presenta otra variable en esa
posición:
Ejemplo 10.27. ¿Cómo se llaman los sujetos con una perı́metro de cintura
menor de 50 cm?
> (x <- which(waist < 50))
[1] 7 10 20 21 22 24 25 26 28 29 42
> nom[x]
[1] "Clara" "Marta" "Gorka" "José" "Alberto" "Juan"
[7] "Paco" "José" "Juan" "Pablo" "Chema"
> age[x]
[1] 3 7 4 4 36 3 3 3 1 1 1
Observamos que el sujeto en posición 22, con una edad de 36 años y llama-
do Alberto tiene una perı́metro de cintura menor de 50 cm; ¡es un error!
También podemos extraer los elementos que cumplen una determinada
condición; por ejemplo, los que tienen un perı́metro de cintura mayor de 90
cm.

10.5. MANIPULACIÓN DE VECTORES 111
> (x <- which(waist > 90))

[1] 8
www.editorialuc.es
> waist[8]
[1] 93
Ejemplo 10.28. Encuentre en la Tabla 10.1 el nombre, edad y sexo del sujeto
con menor perı́metro de cintura.
> (x <- which.min(waist))

[1] 28
> waist[x]
[1] 43.2
> nom[x]
[1] "Juan"
> age[x]
[1] 1
> sex[x]
[1] "M"
Juan, de 1 año y sexo M presenta el menor perı́metro de cintura.
Ejemplo 10.29. ¿Cuánto mide el perı́metro de la cintura de Mónica?
> waist[nom == ’Mónica’] # incorrecto

[1] NA 77
> x <- which(nom == ’Mónica’) # correcto
> waist[x]
[1] 77
10.5.2. Cambio del valor de algún elemento

Cambiar el valor de un elemento es muy fácil; no hay que hacer nada más
que referirse a ese elemento por su posición y asignarle el nuevo valor:
Ejemplo 10.30. Supongamos que el perı́metro de la cintura del primer sujeto

(Pedro) no era 86.2, sino que era 89.2 ¿Cómo lo podemos corregir?
> waist[1] # ver el valor que tenı́a

[1] 86.2
> waist[1] <- 89.2 # se cambia
> waist[1] # ver el valor que tiene
[1] 89.2
El paquete epicalc tiene una función muy útil en este sentido llamada
recode(). Solo actúa sobre variables que están en un data frame.
#---------------------------------------------------------------
recode(vars, old.value, new.value, dataFrame = .data, ...)
#---------------------------------------------------------------
Ejemplo 10.31. Deshacer el cambio anterior porque el perı́metro de la cintura

de 86.2 cm era el valor correcto.
> waist[1] <- 86.2 # vuelve a su valor original

10.5.3. Ordenación de elementos

Cuando se teclea el nombre de un vector se imprime (en la consola) en
mismo orden en que se generó dicho vector. En ocasiones interesa que aparezca
ordenado alfabéticamente (o en orden numérico creciente). En otras ocasiones
interesa que el orden sea al revés. R dispone de las funciones sort(), rev()
para realizar ordenaciones muy cómodamente.
#---------------------------------------------------------------
sort(x, decreasing = FALSE, ...)
rev(x)
#---------------------------------------------------------------
> age # orden en que se ha tecleado

[1] 42 39 13 12 9 NA 3 37 34 7 28 26 NA 42 42 10 38 37 6 4
[21] 4 36 32 3 3 3 32 1 1 42 39 13 12 37 34 16 14 14 7 29
[41] 22 1
> sort(age) # ordenación numérica creciente
[1] 1 1 1 3 3 3 3 4 4 6 7 7 9 10 12 12 13 13 14 14
[21] 16 22 26 28 29 32 32 34 34 36 37 37 37 38 39 39 42 42 42 42
> rev(age) # orden invertido en que se ha tecleado
[1] 1 22 29 7 14 14 16 34 37 12 13 39 42 1 1 32 3 3 3 32
[21] 36 4 4 6 37 38 10 42 42 NA 26 28 7 34 37 3 NA 9 12 13
[41] 39 42
> rev(sort(age)) # ordenación numérica decreciente
[1] 42 42 42 42 39 39 38 37 37 37 36 34 34 32 32 29 28 26 22 16
[21] 14 14 13 13 12 12 10 9 7 7 6 4 4 3 3 3 3 1 1 1
> sort(nom) # Ordenación alfabética de los nombres
[1] "Alberto" "Ana" "Andrea" "Antón" "Aylı́n" "Carmen"
[7] "Carmen" "Chema" "Clara" "Dolores" "Emil" "Gabriel"
[13] "Gloria" "Gorka" "Isis" "José" "José" "Juan"
[19] "Juan" "Juan" "Juan" "Leonor" "Lucı́a" "Luis"
[25] "Marcos" "Marı́a" "Marı́a" "Marina" "Marina" "Marta"
[31] "Marta" "Martı́n" "Miguel" "Mónica" "Pablo" "Paco"
[37] "Paco" "Paz" "Pedro" "Pepe" "Pilar"
10.5.4. Eliminación de vectores

Para eliminar un vector basta con poner su nombre como argumento de la
función remove() o rm().
#---------------------------------------------------------------
remove(..., list = character(), pos = -1,
envir = as.environment(pos), inherits = FALSE)
rm (..., list = character(), pos = -1,

envir = as.environment(pos), inherits = FALSE)
#---------------------------------------------------------------
Ejemplo 10.32. Elimine el vector x.

10.6. FUNCIONES VECTORIALES 113
> ls() # listado de los objetos que hay

[1] "age" "alive" "family" "height" "id"
www.editorialuc.es
[6] "nom" "relative" "sex" "w" "waist"
[11] "weight" "x" "z"
> rm(x) # se borra x
> ls() # comprobamos que se ha borrado
[1] "age" "alive" "family" "height" "id"
[6] "nom" "relative" "sex" "w" "waist"
[11] "weight" "z"
10.5.5. Grabación de vectores

Hay muchas formas de grabar vectores. Por ahora, simplemente usará la
función save() para grabar los vectores que ha creado con los datos de las
familias: id, family, relative, nom, age, alive, sex, weight, height,
waist. Cuando ejecute el ejemplo, podrá comprobar que en su directorio de
trabajo se ha creado un fichero llamado vectores familias.RData.
#---------------------------------------------------------------
save(..., list = character(0L),
file = stop("’file’ must be specified"),
ascii = FALSE, version = NULL, envir = parent.frame(),
compress = !ascii, compression_level,
eval.promises = TRUE, precheck = TRUE)
save.image(file = ".RData", version = NULL, ascii = FALSE,

compress = !ascii, safe = TRUE)
#---------------------------------------------------------------
Ejemplo 10.33. Grabe los vectores de los datos de las familias en un objeto
llamado vectores familias.RData.
> save(id, family, relative, nom, age,

+ alive, sex, weight, height, waist,
+ file = ’vectores_familias.RData’)
10.6. Funciones vectoriales

Existen muchas funciones que pueden operar con vectores. En la Tabla 10.3
se nombran las de uso más frecuente que se estudiarán más adelante. Para ver
su utilidad vamos a realizar unos ejemplos.
Ejemplo 10.34. Calcule la edad media de los sujetos del ejemplo familias.
Como hay algún dato ausente, antes hay que removerlo.
> mean(age, na.rm = TRUE)

[1] 20.6
Ejemplo 10.35. Calcule la mediana de la edad de los sujetos del ejemplo

familias.

Tabla 10.3: Funciones vectoriales
Función Acción
min(x) Valor mı́nimo del vector x
max(x) Valor máximo
range(x) Rango, vector con dos elementos: min(x) y max(x)
sum(x) Suma de todos los elementos
median(x) Mediana del vector x
mean(x) Media del vector x
mode(x) Moda del vector x
sd(x) Desviación estándar del vector x
var(x) Variancia del vector x
quantile(x) Vector con min(x), Q1, mediana, Q3 y max(x)
cumsum(x) Vector con las sumas acumuladas del vector x
cumprod(x) Vector con los productos acumulados del vector x
cummin(x) Vector no crecientes con el mı́nimo acumulado hasta ese
punto
cummax(x) Vector no decrecientes con el máximo acumulado hasta ese
punto
> median(age, na.rm = TRUE)

[1] 15
Ejemplo 10.36. Calcule la desviación estándar de la edad de los sujetos del

ejemplo familias.
> sd(age, na.rm = TRUE)

[1] 15.00051
Ejemplo 10.37. De los sujetos cuyo nombre comienza por la letra ((M)) o la
letra ((J)) calcule la suma de sus edades y presente sus nombres. ¿Están todos
vivos?
> x <- which(substr(nom, 1, 1) == ’M’ |

+ substr(nom, 1, 1) == ’J’)
> list(id = x,
+ suma_de_edades = sum(age[x], na.rm = TRUE),
+ nombres = nom[x],
+ estan_vivos = alive[x])
$id
[1] 2 3 5 6 9 10 11 15 21 24 26 27 28 31 32 37
$suma_de_edades
[1] 281
$nombres
[1] "Marı́a" "Juan" "Marcos" "Miguel" "Marta" "Marta"

[7] "Martı́n" "Mónica" "José" "Juan" "José" "Marina"

[13] "Juan" "Marı́a" "Juan" "Marina"
www.editorialuc.es
$estan_vivos
[1] TRUE TRUE TRUE FALSE TRUE TRUE TRUE TRUE TRUE TRUE
[11] TRUE TRUE TRUE TRUE TRUE TRUE

tablas:
Función Acción
Arg() Argumento de un número complejo
assign() Asigna un valor a un elemento de un vector
attributes() Atributos de un objeto
c() Crea un vector concatenando elementos
bind() Unión de objetos por columnas
complex() Crea un vector numérico complejo
Conj() Conjugado de un número complejo
cummax(X) Vector no decrecientes con el máximo acumulado has-
ta ese punto
cummin(X) Vector no crecientes con el mı́nimo acumulado hasta
ese punto
cumprod(X) Vector con los productos acumulados del vector X
cumsum(X) Vector con las sumas acumuladas del vector X
data.frame() Crea una data frame
double() Crea un vector numérico coma-flotante
factor() Crea un factor
Im() Parte imaginaria de un número complejo
integer() Crea un vector de enteros
is.atomic() Comprueba que es de tipo atómico
is.character() Comprueba que es de tipo carácter
is.double() Comprueba que es de tipo numérico flotante
is.integer() Comprueba que es de tipo numérico entero
is.list() Comprueba que es de tipo lista
is.logical() Comprueba que es de tipo lógico
is.na() Comprueba si el elemento es NA
length() Longitud de un vector
list() Crea una lista
logical() Crea un vector lógico
max(X) Valor máximo
mean(X) Media del vector X
median(X) Mediana del vector X
min(X) Valor mı́nimo del vector X
Mod() Módulo de un número complejo

Función Acción
mode() Evalúa el modo de un objeto
names() Asigna nombres
nchar() Longitud (número de caracteres) de una cadena
paste() Une distintos elementos en uno sólo
quantile(X) Vector con min(X), Q1, mediana, Q3 y max(X)
range(X) Rango, vector con dos elementos: min(X) y max(X)
Re() Parte real de un número complejo
remove() Borra objetos de la memoria de trabajo
rep() Crea una secuencia repitiendo elementos
rev() Revierte el orden
rm() Borra objetos de la memoria de trabajo
rnorm() Números aleatorios según una distribución normal
save() Guarda objetos en un fichero de datos
save.image() Guarda objetos en un fichero de datos
scan() Crea un lector leyendo datos
sd(X) Desviación estándar del vector X
seq() Crea una secuencia
setNames() Asigna nombres
sort() Ordena un vector en orden creciente
sqrt() Raı́z cuadrada
strsplit() Divide una cadena de caracteres
substr() Extrae una subcadena
sum(X) Suma de todos los elementos
table() Genera una tabla
tolower() Convierte en minúsculas
toupper() Convierte en mayúsculas
typeof() Tipo de objeto
var(X) Variancia del vector X
vector() Crea un vector
which() Pregunta qué elemento cumple una condición (devuel-
ve el ı́ndice)
which.min() Mı́nimo según una condición
which.max() Máximo según una condición
PROBLEMAS
Problema 1. ¿Cuál será el resultado de dividir 1:10 entre 3:5?
Problema 2. Cree un vector, llamado Id.caso, para etiquetar cada uno de los casos de
un estudio (n = 27) como Caso-1, ..., Caso-27.
Problema 3. Elimine todos los objetos que tenga en su área de trabajo que comienzan
por la letra I (mayúscula).
Problema 4. ¿Es posible sumar dos vectores numéricos de distinta longitud?

Problema 5. ¿Cómo puede crear el vector numérico formado por 0, 3, 6, 9, 12, 15,
18 y 24 empleando la función seq() en una única expresión?
www.editorialuc.es
Problema 6. Si x <- 1:15, ¿qué longitud tendrá x[c(1, -15)]? (responda
antes de comprobar la respuesta)

www.editorialuc.es
Capı́tulo 11
Factores
Los factores son vectores utilizados para almacenar datos de tipo cualitativo
[151]. Son variables categóricas con un número fijo de categorı́as o niveles [167].
Constituyen una manera compacta (y, por tanto, muy eficiente) de manejar
datos cualitativos, por lo que son muy utilizados en R.
Los vectores de la clase factor se diferencian de los vectores de la clase cha-
racter en la manera en que almacenan la información [97], mientras que los
vectores de cadenas de caracteres almacenan todos los caracteres entrecomi-
llados ocupando memoria, los vectores de factores almacenan únicamente un
número que se corresponde a cada uno de sus niveles, con valores 1, 2, 3, ..., k,
siendo k el número de categorı́as [101]. Este se entiende perfectamente con un
ejemplo.
Ejemplo 11.1. Suponga que en un Centro de Atención Primaria se registra el

origen de las primeras 30 personas extranjeras de la UE atendidas durante el
mes de julio. Se quiere ver cómo se almacenan los datos en una variable de
caracteres y en otra factor.
La variable pais c almacena los 30 paı́ses de origen de estas personas; se
trata de un vector de caracteres como se puede comprobar con class(pais c).
Cuando se imprime el vector, cada elemento es entrecomillado, ya que se trata
de un vector de caracteres. Creemos también un vector factor llamado pais f
con la función as.factor(). Una vez creado se puede comprobar que es un
factor con class(pais f), por lo que al imprimirlo sus elementos no apare-
cen entrecomillados y además presenta cuántos niveles hay; esta presentación
sigue, por defecto, un orden alfabético.
Si al vector pais f le quitamos la clase con la función unclass(), podre-
mos apreciar que lo almacenado no son los nombres de los paı́ses, sino unos
números consecutivos correspondientes cada uno a un nivel del factor, ası́ ocu-
pan menos memoria y las operaciones son más rápidas.
> pais_c <- c(’Alemania’, ’Francia’, ’Inglaterra’, ’Alemania’,
+ ’Alemania’, ’Francia’, ’Francia’, ’Francia’,
+ ’Holanda’, ’Portugal’, ’Suecia’, ’Alemania’,
+ ’Portugal’, ’Alemania’, ’Italia’, ’Polonia’,
+ ’Alemania’, ’Francia’, ’Holanda’, ’Alemania’,
+ ’Dinamarca’, ’Suecia’, ’Rumanı́a’, ’Rumanı́a’,
+ ’Rumanı́a’, ’Austria’, ’Alemania’, ’Francia’,
119
120 CAPÍTULO 11. FACTORES
+ ’Alemania’, ’Alemania’)
> # vector factor
> pais_f <- as.factor(pais_c)
> class(pais_c) # tipo de vector: character
[1] "character"
> pais_c # caracteres (entrecomillado)
[1] "Alemania" "Francia" "Inglaterra" "Alemania"
[5] "Alemania" "Francia" "Francia" "Francia"
-------------------- lineas omitidas --------------------
[25] "Rumanı́a" "Austria" "Alemania" "Francia"
[29] "Alemania" "Alemania"
> class(pais_f) # tipo de vector: factor
[1] "factor"
> pais_f # nombres sin comillas
[1] Alemania Francia Inglaterra Alemania Alemania
[6] Francia Francia Francia Holanda Portugal
-------------------- lineas omitidas --------------------
[26] Austria Alemania Francia Alemania Alemania
11 Levels: Alemania Austria Dinamarca Francia ... Suecia
> unclass(pais_f) # almacena números
[1] 1 4 6 1 1 4 4 4 5 9 11 1 9 1 7 8 1 4 5
[20] 1 3 11 10 10 10 2 1 4 1 1
attr(,"levels")
[1] "Alemania" "Austria" "Dinamarca" "Francia"
[5] "Holanda" "Inglaterra" "Italia" "Polonia"
[9] "Portugal" "Rumanı́a" "Suecia"
En el siguiente ejemplo se crean dos vectores (uno de caracteres y otro

numérico) que utilizaremos más adelante.
Ejemplo 11.2. Un investigador ha recogido la variable sexo de sus 54 su-

jetos sometidos a estudio: hombre, mujer, mujer, hombre, hombre, hombre,
mujer, hombre, mujer, mujer, mujer, mujer, mujer, hombre, hombre, mujer,
hombre, hombre, mujer, mujer, hombre, mujer, mujer, hombre, hombre, mu-
jer, hombre, mujer, mujer, mujer, hombre, mujer, hombre, hombre, hombre,
mujer, mujer, hombre, mujer, hombre, hombre, mujer, hombre, mujer, hom-
bre, mujer, mujer, mujer, mujer, hombre, mujer, mujer, hombre, mujer. Tam-
bién registró sus edades (en años cumplidos): 34, 40, 31, 33, 32, 31, 38, 30, 31,
35, 31, 26, 30, 30, 39, 33, 36, 34, 40, 34, 32, 36, 36, 37, 38, 28, 25, 31, 29, 26, 29,
44, 34, 32, 28, 34, 32, 33, 41, 37, 36, 36, 23, 39, 31, 29, 28, 28, 27, 27, 30, 38, 30, 32.
Se le pide que cree dos vectores, uno de caracteres (sexo) y otro numérico
(edad).
> sexo <- c(’hombre’, ’mujer’, ’mujer’, ’hombre’, ’hombre’,

+ ’hombre’, ’mujer’, ’hombre’, ’mujer’, ’mujer’,
+ ’mujer’, ’mujer’, ’mujer’, ’hombre’, ’hombre’,
+ ’mujer’, ’hombre’, ’hombre’, ’mujer’, ’mujer’,
+ ’hombre’, ’mujer’, ’mujer’, ’hombre’, ’hombre’,
+ ’mujer’, ’hombre’, ’mujer’, ’mujer’, ’mujer’,
+ ’hombre’, ’mujer’, ’hombre’, ’hombre’, ’hombre’,
+ ’mujer’, ’mujer’, ’hombre’, ’mujer’, ’hombre’,
+ ’hombre’, ’mujer’, ’hombre’, ’mujer’, ’hombre’,
+ ’mujer’, ’mujer’, ’mujer’, ’mujer’, ’hombre’,

11.1. CREANDO FACTORES 121
+ ’mujer’, ’mujer’, ’hombre’, ’mujer’)

> edad <- c(34, 40, 31, 33, 32, 31, 38, 30, 31, 35, 31, 26,
www.editorialuc.es
+ 30, 30, 39, 33, 36, 34, 40, 34, 32, 36, 36, 37,
+ 38, 28, 25, 31, 29, 26, 29, 44, 34, 32, 28, 34,
+ 32, 33, 41, 37, 36, 36, 23, 39, 31, 29, 28, 28,
+ 27, 27, 30, 38, 30, 32)
11.1. Creando factores

En la práctica un factor no es muy diferente de un vector de caracteres [150]:
un factor tiene un limitado número de valores, se almacena más eficientemen-
te (se guardan números que ocupan menos memoria) y son necesarios para
algunos procedimientos estadı́sticos. Habitualmente el primer nivel suele ser
el nivel de referencia, aunque se puede cambiar si es necesario.
Los factores se pueden crear con las funciones as.factor(), factor(),
ordered(), cut().
11.1.1. La función as.factor()

La función as.factor() crea una copia del vector que se pasa como paráme-
tro.
#---------------------------------------------------------------
as.factor(x)
#---------------------------------------------------------------
Ejemplo 11.3. Cree el factor sexo f1 empleando la función as.factor().
> (sexo_f1 <- as.factor(sexo))

[1] hombre mujer mujer hombre hombre hombre mujer hombre
[9] mujer mujer mujer mujer mujer hombre hombre mujer
-------------------- lineas omitidas --------------------
[49] mujer hombre mujer mujer hombre mujer
Levels: hombre mujer
11.1.2. La función factor()

La función factor() también crea un factor, que cuando se imprime pre-
senta los valores sin entrecomillar y los niveles ordenador alfabéticamente.
Aunque presente los niveles ordenados alfabéticamente el factor no está or-
denado, como se puede comprobar con la función is.ordered():
#---------------------------------------------------------------
factor(x = character(), levels, labels = levels,
exclude = NA, ordered = is.ordered(x), nmax = NA)
#---------------------------------------------------------------
factor() primero calcula cuántas cadenas de caracteres diferentes exis-

ten en el vector (k), después las ordena alfabéticamente y las asigna un número
de posición (1, 2, ..., k), finalmente crea un vector formado por los números co-
rrespondientes a las cadenas de caracteres en el orden original. El número de
cadenas distintas son los niveles (levels).

Ejemplo 11.4. Cree el factor sexo f2 utilizando la función factor(). ¿Es

un factor ordenado? Calcule cuántos hombres hay y cuántas mujeres. ¿Quién
es la categorı́a de referencia?
> (sexo_f2 <- factor(sexo))

-------------------- lineas omitidas --------------------
Levels: hombre mujer
> is.ordered(sexo_f2)
[1] FALSE
> sum(unclass(sexo_f2) == 1) # hombres
[1] 24
> sum(unclass(sexo_f2) == 2) # mujeres
[1] 30
> table(sexo_f2) # lo mismo (más sencillo)
sexo_f2
hombre mujer
24 30
> levels(sexo_f2)[1] # categorı́a de referencia
[1] "hombre"
Para encontrar la categorı́a de referencia (el primer nivel) hemos empleado la

función levels() que devuelve un vector con todas las categorı́as:
> levels(sexo_f2) # categorı́as

[1] "hombre" "mujer"
y hemos seleccionado la primera categorı́a.

Cuando se quiere crear un factor con más niveles que las categorı́as presen-
tes en el vector de caracteres, hay que utilizar el argumento levels y declarar
esa categorı́a extra explı́citamente. Supongamos que podrı́amos encontrarnos
una persona con sexo indeterminado, a partir del vector de caracteres sexo po-
demos crear un factor sexo de la siguiente manera:
(sexo_f3 <- factor(sexo,

levels = c(’hombre’, ’mujer’,
’indeterminado’)))
table(sexo_f3)
sexo_f3
hombre mujer indeterminado
24 30 0
se aprecia que se ha creado la categorı́a indeterminado, pero sin ningún caso.

Si se quiere crear un factor en que las categorı́as tengan otro orden, se deben
declarar explı́citamente con el parámetro levels:
> (sexo_f4 <- factor(sexo, levels = c(’mujer’, ’hombre’)))

-------------------- lineas omitidas --------------------
Levels: mujer hombre

11.1. CREANDO FACTORES 123
> table(sexo_f4)
sexo_f4
www.editorialuc.es
mujer hombre
30 24
Se observa que ahora las categorı́as no siguen un orden alfabético, sino el

orden que nosotros hemos determinado.
Hay que ser muy cuidadoso con levels y labels, el primero se refiere a
la entrada y el segundo a la salida [95].
11.1.3. Las función ordered()

La función ordered() crea un factor con un orden en sus niveles, por lo
que pueden ser comparados usando los operadores relacionales <, <=, >, >=,
==, != [101]. Desafortunadamente R trata los factores ordenados como equidis-
tantes en algunos modelos estadı́sticos, por ejemplo en contrastes polinómicos,
por lo que no es muy aconsejable utilizarlos [95].
#---------------------------------------------------------------
ordered(x, ...)
#---------------------------------------------------------------
Ejemplo 11.5. Cree el vector factor sexo f5 con sus niveles ordenados.
> (sexo_f5 <- ordered(sexo))
-------------------- lineas omitidas --------------------
Levels: hombre < mujer
> is.ordered(sexo_f5)
[1] TRUE
Se observa que R presenta los niveles separados por el signo ((<)), indicando
que es un factor ordenado.
11.1.4. La función cut()

En ocasiones interesa transformar una variable numérica en una cualitativa,
por ejemplo, en una encuesta se registra el hábito tabáquico como el número de
cigarrillos que fuma una persona cada dı́a, pero en algún momento del análisis
estadı́stico interesa categorizar esta variable para expresar los resultados en
función de si son ((no fumadores)), ((poco fumadores)), ((muy fumadores)). R
dispone de una función (cut()) que facilita enormemente este proceso.
#---------------------------------------------------------------
cut(x, breaks, labels = NULL,
include.lowest = FALSE, right = TRUE, dig.lab = 3,
ordered_result = FALSE, ...)
#---------------------------------------------------------------
El paquete Hmisc tiene la función cut2 de manejo más sencillo y con ma-
yores posibilidades, como descubrirá el lector consultando la ayuda correspon-
diente [168].

#---------------------------------------------------------------
cut2(x, cuts, m, g, levels.mean, digits, minmax=TRUE,
oneval=TRUE, onlycuts=FALSE)
#---------------------------------------------------------------
Ejemplo 11.6. Categorice la edad en tres grupos, con puntos de corte en 20,
30, 40 y 50 años.
Con la función cut() vamos a crear el factor edad f1. Esta función crea
un factor dividiendo la variable edad según los puntos de corte especificados
con breaks=c(20, 30, 40, 50), de forma que divide entre los 20 años de
edad y los 30 (sin incluir a los 30), entre los 30 (incluido) hasta los 40 (excluido)
y entre los 40 y 50 (ambos incluidos):
> edad_f1 <- cut(edad,

+ breaks = c(20, 30, 40, 50),
+ include.lowest = TRUE,
+ right = FALSE)
> edad_f1
[1] [30,40) [40,50] [30,40) [30,40) [30,40) [30,40) [30,40)
[8] [30,40) [30,40) [30,40) [30,40) [20,30) [30,40) [30,40)
-------------------- lineas omitidas --------------------
[43] [20,30) [30,40) [30,40) [20,30) [20,30) [20,30) [20,30)
[50] [20,30) [30,40) [30,40) [30,40) [30,40)
Levels: [20,30) [30,40) [40,50]
> is.ordered(edad_f1)
[1] FALSE
Se habrı́a conseguido lo mismo con
> Hmisc::cut2(edad, c(20, 30, 40, 50))

> edad_f1 == Hmisc::cut2(edad, c(20, 30, 40, 50)) # TRUE
Ejemplo 11.7. Cree un factor ordenado edad f2.

En este caso se nos pide que sea un factor ordenado, por lo que utilizando
la función as.ordered() podemos crear el vector solicitado:
> (edad_f2 <- as.ordered(edad_f1))

[1] [30,40) [40,50] [30,40) [30,40) [30,40) [30,40) [30,40)
[8] [30,40) [30,40) [30,40) [30,40) [20,30) [30,40) [30,40)
-------------------- lineas omitidas --------------------
[43] [20,30) [30,40) [30,40) [20,30) [20,30) [20,30) [20,30)
[50] [20,30) [30,40) [30,40) [30,40) [30,40)
Levels: [20,30) < [30,40) < [40,50]
[1] TRUE
La otra forma de crear un vector factor ordenado es con la función cut()

pero utilizando en sus argumentos ordered result = TRUE:
Ejemplo 11.8. Cree el factor ordenado edad f3 empleando la función

cut().

11.2. TIPOS DE FACTORES 125
> (edad_f3 <- cut(edad,

+ breaks = c(20, 30, 40, 50),
www.editorialuc.es
+ include.lowest = TRUE,
+ right = FALSE,
+ ordered_result = TRUE))
[1] [30,40) [40,50] [30,40) [30,40) [30,40) [30,40) [30,40)
[8] [30,40) [30,40) [30,40) [30,40) [20,30) [30,40) [30,40)
-------------------- lineas omitidas --------------------
[43] [20,30) [30,40) [30,40) [20,30) [20,30) [20,30) [20,30)
[50] [20,30) [30,40) [30,40) [30,40) [30,40)
Levels: [20,30) < [30,40) < [40,50]
[1] TRUE
11.2. Tipos de factores

Según la importancia de una categorı́a o nivel de la variable cualitativa,
podemos distinguir dos tipos: a) aquellos en los que cada categorı́a de la va-
riable es igual de importante, como puede ser el grupo sanguı́neo (A, B, AB,
O) y b) aquellos en los que una categorı́a es superior a otra, como sucede en la
respuesta a un tratamiento (muy mala, mala, regular, buena y excelente).
11.2.1. Factores no ordenados

Son los que corresponden a una variable cualitativa dicotómica o multi-
cotómica. R presenta los niveles ordenados alfabéticamente (por defecto) o el
el orden en que se especifique. Esto es importante a la hora de determinados
análisis estadı́sticos en los que se toma una categorı́a como categorı́a de refe-
rencia.
> # 1) factor NO ORDENADO

>
> # con categorı́as en orden alfabético
> (var_f1 <- factor(pais_c))
-------------------- lineas omitidas --------------------
[21] Dinamarca Suecia Rumanı́a Rumanı́a Rumanı́a
11 Levels: Alemania Austria Dinamarca Francia ... Suecia
>
> # con categorı́as según orden asignado por el usuario
> (var_f2 <- factor(pais_c,
+ levels = c(’Portugal’, ’Francia’,
+ ’Italia’, ’Inglaterra’,
+ ’Alemania’, ’Holanda’,
+ ’Dinamarca’, ’Suecia’,
+ ’Polonia’, ’Rumanı́a’,
+ ’Austrı́a’)))
-------------------- lineas omitidas --------------------


[26] <NA> Alemania Francia Alemania Alemania
11 Levels: Portugal Francia Italia Inglaterra ... Austrı́a
11.2.2. Factores ordenados

Corresponden a una variable multicotómica ordenada. R presenta los nive-
les separados por el signo >. También aquı́ las categorı́as pueden estar ordena-
das alfabéticamente (por defecto) o en el orden que establezca el usuario.
> # 2) factor ORDENADO

>
> # con categorı́as en orden alfabético
> (var_f3 <- ordered(pais_c))
-------------------- lineas omitidas --------------------
11 Levels: Alemania < Austria < Dinamarca < ... < Suecia
>
> # con categorı́as según orden asignado por el usuario
> (var_f4 <- ordered(pais_c,
+ levels=c(’Portugal’,’Francia’, ’Italia’,
+ ’Inglaterra’, ’Alemania’,
+ ’Holanda’, ’Dinamarca’,
+ ’Suecia’, ’Polonia’, ’Rumanı́a’,
+ ’Austria’)))
-------------------- lineas omitidas --------------------
11 Levels: Portugal < Francia < Italia < ... < Austria
11.3. Uso de factores en estadı́stica

En la mayorı́a de las ocasiones en que se trabaje con variables cualitativas
con el programa R conviene transformarlas en factor. Si son dicotómicas o mul-
ticotómicas se transformarán en un factor no ordenado o a veces ordenado y
si son variables cualitativas multicotómicas ordenadas se transformarán en un
factor ordenado. En ocasiones conviene modificar el número de niveles o re-
nombrarles; con R no es difı́cil.
11.3.1. Combinar niveles

Para combinar dos o más niveles en uno se crea otro factor con una lista
con los nuevos niveles. Esto suele interesar cuando se deciden agrupar cate-
gorı́as que tienen bajo número de efectivos, o por otra razón relacionada con el
análisis estadı́stico.

11.3. USO DE FACTORES EN ESTADÍSTICA 127
Ejemplo 11.9. Con el vector pais f cree un vector factor que tenga solo dos
niveles (europa este y europa oeste).
www.editorialuc.es
> pais_2f <- pais_f # se crea una copia
> levels(pais_2f) <- list(europa_oeste = c(’Portugal’,
+ ’Francia’,
+ ’Inglaterra’,
+ ’Holanda’,
+ ’Dinamarca’,
+ ’Suecia’,
+ ’Alemania’,
+ ’Italia’,
+ ’Austria’),
+ europa_este = c(’Polonia’,
+ ’Rumanı́a’))
> pais_2f
[1] europa_oeste europa_oeste europa_oeste europa_oeste
[13] europa_oeste europa_oeste europa_oeste europa_este
[21] europa_oeste europa_oeste europa_este europa_este
[25] europa_este europa_oeste europa_oeste europa_oeste
[29] europa_oeste europa_oeste
Levels: europa_oeste europa_este
Existen dos funciones llamadas recode(), una del paquete epicalc y

otra del paquete car, que son de gran utilidad en la recodificación [96, 169].
#---------------------------------------------------------------
epicalc::recode(vars, old.value, new.value,
dataFrame = .data, ...)
car::recode(var, recodes, as.factor.result,
as.numeric.result=TRUE, levels)
#---------------------------------------------------------------
Se aconseja al lector consultar la ayuda para su correcto uso.
Ejemplo 11.10. Utilice la función recode del paquete car para agrupar los
11 niveles del vector pais f en dos niveles, como se ha hecho en el ejemplo
anterior.
> pais_2fcar <- car::recode(pais_f, "c(’Portugal’, ’Francia’,

+ ’Inglaterra’, ’Holanda’, ’Dinamarca’, ’Suecia’, ’Alemania’,
+ ’Italia’, ’Austria’) = ’europaOESTE’;
+ c(’Polonia’, ’Rumanı́a’) = ’europaESTE’")
> pais_2fcar
[1] europaOESTE europaOESTE europaOESTE europaOESTE europaOESTE
[16] europaESTE europaOESTE europaOESTE europaOESTE europaOESTE
[21] europaOESTE europaOESTE europaESTE europaESTE europaESTE
Levels: europaESTE europaOESTE

11.3.2. Cambiar nivel de referencia

El nivel de referencia se puede cambiar con la función relevel().
#---------------------------------------------------------------
relevel(x, ref, ...)
#---------------------------------------------------------------
Ejemplo 11.11. Declare como factor de referencia el nivel europa oeste.
> relevel(pais_2f, ref = ’europa_este’)

[13] europa_oeste europa_oeste europa_oeste europa_este
[21] europa_oeste europa_oeste europa_este europa_este
[25] europa_este europa_oeste europa_oeste europa_oeste
[29] europa_oeste europa_oeste
Levels: europa_este europa_oeste
11.3.3. Número de niveles

El número de niveles se conoce con la función nlevels().
Ejemplo 11.12. ¿Cuántos niveles hay en el factor pais f?
> nlevels(pais_f)
[1] 11
otra forma podrı́a haber sido con

> length(levels(pais_f))
[1] 11
11.3.4. La función gl()

Esta función es útil cuando se quiere crear un vector de niveles de factor.
#---------------------------------------------------------------
gl(n, k, length = n*k, labels = seq_len(n), ordered = FALSE)
#---------------------------------------------------------------
Admite cinco parámetros: el número de niveles, el número de realizaciones,

la longitud del vector resultado, unas etiquetas opcionales y si se desea que sea
ordenado o no.
> gl(4, 2, 37)
[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 1 2 2 3 3
[31] 4 4 1 1 2 2 3
Levels: 1 2 3 4
Ejemplo 11.13. Cree un vector similar, pero etiquetado con las primeras cua-
tro letras mayúsculas.

11.3. USO DE FACTORES EN ESTADÍSTICA 129
> gl(4, 2, 37, paste(’Centro’, LETTERS[1:4], ’’))

[1] Centro A Centro A Centro B Centro B Centro C Centro C
www.editorialuc.es
[7] Centro D Centro D Centro A Centro A Centro B Centro B
[13] Centro C Centro C Centro D Centro D Centro A Centro A
[19] Centro B Centro B Centro C Centro C Centro D Centro D
[25] Centro A Centro A Centro B Centro B Centro C Centro C
[31] Centro D Centro D Centro A Centro A Centro B Centro B
[37] Centro C
Levels: Centro A Centro B Centro C Centro D
11.3.5. La función tapply() de la familia apply

Hay una serie de funciones que trabajan utilizando factores, aplicando ite-
rativamente una función a un conjunto de entradas [94], como se recogen en la
Tabla 11.1.
Tabla 11.1: La familia de funciones apply [94]
Operación Resultado
apply() matrices, arrays, data frame
lapply() listas, vectores
sapply() listas, vectores
tapply() vectores
by() similar a tapply()
eapply entornos
mapply múltiples valores
rapply versión recursiva de lapply()
La función tapply(), que admite tres parámetros: vector numérico,

factor y función, permite aplicar una función a cada uno de lo grupos de
un vector numérico delimitados por un factor.
#---------------------------------------------------------------
tapply(X, INDEX, FUN = NULL, ..., simplify = TRUE)
#---------------------------------------------------------------
La gram utilidad de tapply() es que permite aplicar cualquier función

que pueda ser aplicada a un vector [170].
Ejemplo 11.14. Calcule el número de sujetos, la media y la desviación

estándar de la edad, según el sexo, en los sujetos del ejemplo.
> tapply(edad, sexo_f1, length) # número de sujetos y sexo

hombre mujer
24 30
> tapply(edad, sexo_f1, mean) # media de edad según sexo
hombre mujer
32.125 33.100
> tapply(edad, sexo_f1, sd) # DE de la edad según sexo
hombre mujer

4.035845 4.837711
> tapply(edad, sexo, mean) # también con vector cadena
hombre mujer
32.125 33.100
Incluso se puede ejecutar por una lista de factores. Ası́, cuando queremos
calcular la desviación estándar de la edad según sexo y en cada uno de los
grupos de edad categorizada:
> # DE de la edad según sexo y grupo de edad

> tapply(edad, list(sexo_f1, edad_f2), sd)
[20,30) [30,40) [40,50]
hombre 2.408319 2.832559 NA
mujer 1.187735 2.926664 1.892969
Ejemplo 11.15. Con los datos del ejemplo 2, presente de forma compacta el
número de sujetos, la media, la desviación estándar, la mediana y el rango
de la edad según sexo.
> n <- tapply(edad, sexo, length)

> m <- tapply(edad, sexo, mean)
> s <- tapply(edad, sexo, sd)
> md <- tapply(edad, sexo, median)
> l <- tapply(edad, sexo, min)
> u <- tapply(edad, sexo, max)
> cbind(N = n, mean = m, SD = s, median = md,
+ lower = l, upper = u)
N mean SD median lower upper
hombre 24 32.125 4.035845 32 23 39
mujer 30 33.100 4.837711 32 26 44

Tabla:
Función Acción
c() Crea un vector concatenando elementos
class() Informa de la clase de un objeto
as.factor() Convierte en factor
unclass() Elimina el atributo clase
factor() Convierte en factor
ordered() Convierte en factor ordenado
cut() Categoriza un vector numérico
cut2() Categoriza un vector numérico
as.ordered() Convierte en factor ordenado
tapply() Aplica una función a cada uno de los grupos de un vector
numérico

Función Acción
levels() Extrae los niveles de un factor
www.editorialuc.es
recode() Recodifica variables
nlevels() Número de niveles
PROBLEMAS
Se tiene una BdD formada por los siguientes vectores: edad, sexo, estado
nutricional y hábitat de 2000 sujetos.
> set.seed(2016)
> n <- 2000
> edad <- rpois(n, 26)
> sexo <- sample(c(’F’, ’M’), n, replace = TRUE)
> en <- sample(c(’D’, ’E’, ’S’,’O’), n, replace = TRUE,
+ prob = c(5, 50, 30, 15) / 100)
> habitat <- sample(c(’rural’, ’semiurbano’, ’urbano’), n,
+ replace = TRUE, prob = c(.1, .4, .5))
Con esta BdD se le plantean varios problemas:

Problema 1. Calcular la edad media de los sujetos según el sexo.
Problema 2. Calcular la edad media de los sujetos según el hábitat.
Problema 3. Calcular la edad media de los sujetos según el hábitat y el estado nutri-
cional.
Problema 4. Calcular la variancia de la edad de los sujetos según el hábitat, estado
nutricional y sexo.
Problema 5. Convertir el hábitat en un factor.
Problema 6. Convertir el hábitat en un factor con nivel de referencia la categorı́a
úrbano’.
Problema 7. Convertir el estado nutricional, primero en un factor de cuatro cate-
gorı́as, y después reconvertirle en uno de dos, agrupando ((D)) y ((E)) como ((normal))
y agrupando ((S)) y ((O)) como ((exceso de peso)).
Problema 8. ¿Qué grupo presenta más variabilidad, medida von la variancia, el
grupo normal o el que tiene exceso de peso?

www.editorialuc.es
Capı́tulo 12
Tablas
Las tablas permiten resumir la información de variables, fundamentalmen-

te cualitativas, por lo que son muy utilizadas en Ciencias de la Salud. Cuando
solo es una variable se llaman Tablas de Frecuencia y si son dos o más se lla-
man Tablas de Contingencia, en las que se ponen de manifiesto la relación
existente entre los valores de las celdas [137].
R dispone de varias funciones para manejar las tablas: table(), xtabs()
y ftable(), prop.table(), margin.table() y addmargins(). Hay al-
gunos paquetes que proporcionan otras funciones para realizar la misma tarea,
como veremos.
Para explorar estas funciones se utilizarán los datos de las familias recogi-
dos en la Tabla 10.1.
12.1. La función table()

La función table() es la más sencilla de usar. Crea tabla de frecuencia con
una variable y tabla de contingencia con dos variables.
#---------------------------------------------------------------
table(...,
exclude = if (useNA == "no") c(NA, NaN),
useNA = c("no", "ifany", "always"),
dnn = list.names(...), deparse.level = 1)
as.table(x, ...)
is.table(x)
#---------------------------------------------------------------
Esta función ignora, por defecto, los datos ausentes (NA).
12.1.1. Tabla de frecuencias

Cuando se le pasa una única variable cualitativa crea una tabla de frecuen-
cias.
Ejemplo 12.1. ¿Cuántos miembros componen cada una de las familias?
133
134 CAPÍTULO 12. TABLAS
Aquı́ queremos ver el número de sujetos de cada una de las familias, es de-
cir, cuántas veces se repite el código de cada familia. La variable family es una
variable cualitativa que se puede tabular, pero table() nos presenta los datos
ordenados alfabéticamente; para que aparezcan correctamente, antes debemos
convertirla en factor y declarar los niveles en el orden que nos interesa.
> load(’vectores_familias.RData’)
> familias <- paste(’F’, 1:10, sep=’’)
> (x <- table(factor(family, levels = familias)))
F1 F2 F3 F4 F5 F6 F7 F8 F9 F10
7 3 3 3 5 5 3 4 6 3
> class(x)
[1] "table"
Con esta función es muy fácil hacer TF de variables cualitativas, aunque

la estética no sea muy agradable. En este sentido el paquete epicalc tiene
la función tab1() que crea tablas de frecuencia con una presentación más
agradable e informa de los ((NA)) si existen y se acompaña de una gráfico de
barras.
#---------------------------------------------------------------
tab1(x0, decimal = 1, sort.group = c(FALSE, "decreasing",
"increasing"), cum.percent = !any(is.na(x0)), graph = TRUE,
missing = TRUE, bar.values = c("frequency",
"percent", "none"), horiz = FALSE, cex = 1, cex.names = 1,
main = "auto", xlab = "auto", ylab = "auto", col = "auto",
gen.ind.vars = FALSE, ...)
#---------------------------------------------------------------
Ejemplo 12.2. Repita el ejemplo anterior empleando tab1.
> epicalc::tab1(factor(family, levels = familias),

+ main = ’Distribution of family’)
factor(family, levels = familias) :

Frequency Percent Cum. percent
F1 7 16.7 16.7
F2 3 7.1 23.8
F3 3 7.1 31.0
F4 3 7.1 38.1
F5 5 11.9 50.0
F6 5 11.9 61.9
F7 3 7.1 69.0
F8 4 9.5 78.6
F9 6 14.3 92.9
F10 3 7.1 100.0
Total 42 100.0 100.0
12.1.2. Tabla de contingencia

Cuando se pasan a la función table() dos variables como argumentos, la
primera determinará el número de filas y la segunda el número de columnas

12.1. LA FUNCIÓN TABLE() 135
Figura 12.1: Miembros en cada una de las 10 familias.
www.editorialuc.es
Distribution of family
7
7
6
6
5 5
5
Frequency
4
4
3 3 3 3 3
3
2
1
0
F1 F2 F3 F4 F5 F6 F7 F8 F9 F10
de la TC que formará: en filas se ponen cada una de las r categorı́as de una

variable y en columnas cada una de las f categorı́as de la segunda variable,
ası́ se forma una matriz de r × f celdas, cada una de ellas con los efectivos que
cumplen las dos condiciones.
La función prop.table() calcula las proporciones por filas o por colum-
nas.
#---------------------------------------------------------------
prop.table(x, margin = NULL)
#---------------------------------------------------------------
Ejemplo 12.3. Haga una tabla de los miembros de cada familia según se-
xo utilizando table() y calcule las proporciones de ambos sexos en cada
familia con la prop.table().
> (x <- table(sex, family))

family
sex F1 F10 F2 F3 F4 F5 F6 F7 F8 F9
F 3 1 2 2 2 2 1 1 2 5
M 4 2 1 1 1 3 4 2 2 1
> round(prop.table(x, 2)*100, 0)
family
sex F1 F10 F2 F3 F4 F5 F6 F7 F8 F9
F 43 33 67 67 67 40 20 33 50 83
M 57 67 33 33 33 60 80 67 50 17
No siempre tiene que ser variables cualitativas. En ocasiones también in-

teresa hacer una TF con una variable numérica discreta:
Ejemplo 12.4. Haga una tabla con los miembros de las familias según edad
y sexo utilizando table(). Resuma esta tabla en otra más sencilla.
> (x <- table(sex, age))

age
sex 1 3 4 6 7 9 10 12 13 14 16 22 26 28 29 32 34 36 37 38 39 42
F 0 1 0 1 2 0 1 2 0 2 1 1 1 0 0 2 2 0 1 0 2 1
M 3 3 2 0 0 1 0 0 2 0 0 0 0 1 1 0 0 1 2 1 0 3
> t(x <- table(sex, cut(age, c(0, 20, 45))))

sex
F M
(0,20] 10 11
(20,45] 10 9
De nuevo, el paquete epicalc tiene la función tabpct() que crea TC con

una presentación más agradable e informa de los ((NA)) si existen y se acom-
paña de tablas de porcentajes y un gráfico mosaic plot.
#---------------------------------------------------------------
tabpct(row, column, decimal = 1, percent = c("both", "col",
"row"), graph = TRUE, las = 0, main = "auto", xlab = "auto",
ylab = "auto", col = "auto", ...)
#---------------------------------------------------------------
Ejemplo 12.5. Haga una tabla de contingencia con sexo y edad categorizada
en tres grupos (niño, adolescente y adulto) empleando la función tabpct().
> age3 <- Hmisc::cut2(age, c(10, 20))

> levels(age3) <- c(’niño’, ’adolescente’, ’adulto’)
> tabpct(sex, age3)
Original table
age3
sex niño adolescente adulto Total
F 4 6 10 20
M 9 2 9 20
Total 13 8 19 40
Row percent
age3
sex niño adolescente adulto Total
F 4 6 10 20
(20) (30) (50) (100)
M 9 2 9 20
(45) (10) (45) (100)
Column percent
age3
sex niño % adolescente % adulto %
F 4 (30.8) 6 (75) 10 (52.6)
M 9 (69.2) 2 (25) 9 (47.4)
Total 13 (100) 8 (100) 19 (100)
12.2. La función xtabs()

La función xtabs() es un poco más compleja, ya que exige una fórmula.
#---------------------------------------------------------------
xtabs(formula = ˜., data = parent.frame(), subset, sparse = FALSE,
na.action, exclude = c(NA, NaN), drop.unused.levels = FALSE)
#---------------------------------------------------------------

12.2. LA FUNCIÓN XTABS() 137
Figura 12.2: Distribución del sexo según tres grupos de edad en los miembros de las
10 familias.
www.editorialuc.es
Distribution of age3 by sex
F M
niño
adolescente
age3
adulto
sex
Ejemplo 12.6. Haga una tabla de los miembros de las familias según sexo
utilizando xtabs().
> x <- xtabs(˜ sex + relative)

> x[, c(7:6, 1:5)]
relative
sex padre madre hijo1 hijo2 hijo3 hijo4 hijo5
F 0 10 5 3 1 1 1
M 9 0 5 3 3 1 0
Ejemplo 12.7. En los datasets disponibles en R está esoph, una BdD que
contiene los datos de un estudio de casos y controles llevado a cabo en Fran-
cia [171]. Hay 5 variables: (1) agegp, (2) alcgp, (3) tobgp, (4) ncases y (5)
ncontrols. Se le pide que utilizando la función xtabs() haga unas tablas
de los casos y controles según el consumo de alcohol y otra según el consumo
de tabaco.
> head(esoph, 3)
agegp alcgp tobgp ncases ncontrols
1 25-34 0-39g/day 0-9g/day 0 40
2 25-34 0-39g/day 10-19 0 10
3 25-34 0-39g/day 20-29 0 6
> tail(esoph, 3)
agegp alcgp tobgp ncases ncontrols
86 75+ 80-119 10-19 1 1
87 75+ 120+ 0-9g/day 2 2
88 75+ 120+ 10-19 1 1

> (x <- xtabs(cbind(ncases, ncontrols) ˜ alcgp, data = esoph))
alcgp ncases ncontrols

0-39g/day 29 415
40-79 75 355
80-119 51 138
120+ 45 67
> round(prop.table(x, 1)*100, 1)

0-39g/day 6.5 93.5
40-79 17.4 82.6
80-119 27.0 73.0
120+ 40.2 59.8
El porcentaje de casos aumenta conforme aumenta la ingesta de alcohol.
12.3. La función ftable()

La función ftable() crea tablas planas, con el fin de salvar espacio [172].
Se suele emplear en tablas de contingencia tres o más dimensiones (n-way con-
tingency tables).
#---------------------------------------------------------------
ftable(x, ...)
#---------------------------------------------------------------
Ejemplo 12.8. Haga una tabulación de los miembros de las familias (relati-
ve) según sexo (sex) y su estado (alive) utilizando la función ftable() y la
función ftable() para comprobar el espacio que se ahorra.
Con la función table() se gasta mucho espacio:
> (x <- table(relative, alive, sex))

, , sex = F
alive
relative FALSE TRUE
hijo1 1 4
hijo2 0 3
hijo3 0 1
hijo4 0 1
hijo5 0 1
madre 0 10
padre 0 0
, , sex = M
alive
relative FALSE TRUE
hijo1 0 5
hijo2 0 3
hijo3 0 3

hijo4 1 0
hijo5 0 0
www.editorialuc.es
madre 0 0
padre 0 9
Con la función ftable() se aprecia que la información se ha compactado

mucho.
> ftable(x, col.vars = c(’alive’, ’sex’))

alive FALSE TRUE
sex F M F M
relative
hijo1 1 0 4 5
hijo2 0 0 3 3
hijo3 0 0 1 3
hijo4 0 1 1 0
hijo5 0 0 1 0
madre 0 0 10 0
padre 0 0 0 9

Tabla:
Función Acción
addmargins() Marginales en una tabla
as.table() Convierte en tabla
cut2() Categoriza un vector numérico
factor() Crea una factor
ftable() Crea una tabla plana
head() Primeros 6 elemento
is.table() Evalúa si es una table
levels() Niveles de un factor
load() Lee un fichero
margintable() Marginales en una tabla (por filas o por columnas)
paste() Concatena cadenas
prop.table() Proporciones en una tabla (por filas o por columnas)
round() Redondeo de decimales
tab1() Crea una tabla de una dimensión
table() Crea una tabla de 1, 2 o más entradas
tabpct() Tablas de dos vı́as
tail() Últimos 6 elementos
xtabs() Crea una tabla de 1, 2 o más entradas

PROBLEMAS
Problema 1. Con los datos de las familias, haga una tabla bidimensional con el
número de padres, madres e hijos en cada una de las 10 familias.
Problema 2. Con los datos de las familias creó en un ejemplo anterior una tabla de
contingencia con el sexo (sex) y la edad categorizada en niños, adolescentes y adultos
(age3). Vuelva a crear la tabla y utilizando la función addmargins() se le pide
que añada los totales por filas y columnas.
Problema 3. Con los datos del problema anterior emplee la función prop.table()
para crear tres tablas de proporciones: 1) con los porcentajes por filas, 2) con los por-
centajes por columnas, y 3) con los porcentajes por el total de casos.
Problema 4. Siendo x <- table(sex, age3) ¿Los resultados con las funcio-
nes margin.table(x, 1) y rowSums(x) son iguales?
Problema 5. Siendo x <- table(sex, age3) ¿Los resultados con las funcio-
nes margin.table(x, 2) y colSums(x) son iguales?
Problema 6. Con los datos de las familias presente una tabla de contingencia con la
edad categorizada como niño, adolescente y adulto age3, el sexo sex y las familias
family.

www.editorialuc.es
Capı́tulo 13
Listas
Una lista es un tipo de vector especial, que tiene una longitud determinada
pero, a diferencia de los vectores vistos hasta ahora, puede estar formado por
distintos tipos de elementos, incluso otras listas [150], por tanto, una lista es un
contenedor de otros objetos, es decir, puede verse una lista como una colección
de cajas [170] en las que podemos guardar distingos tipos de objetos.
Las listas se utilizan mucho como resultado de funciones o como resultado
de un análisis estadı́stico. Las listas juegan un papel importantı́simo en R [?],
ya que son la base de los data frame y de la programación orientada a objetos.
Las listas tienen su propia clase, como podemos ver:
> n <- 300

> a <- sample(letters[1:26], n, replace = TRUE)
> b <- sample(1:(4 * n), n, replace = TRUE)
> c <- sample(c(FALSE, TRUE), n, replace = TRUE)
> objeto_lista <- list(a, b, c)
> objeto_lista
[[1]]
[1] "i" "h" "b" "n" "v" "i" "w" "n" "m" "l" "o" "c" "j" "j" "z"
-------------------- lı́neas omitidas --------------------
[286] "w" "b" "t" "g" "g" "i" "z" "z" "n" "a" "h" "v" "j" "k" "t"
[[2]]
[1] 635 670 1097 693 352 205 128 852 484 1035 92 161
-------------------- lı́neas omitidas --------------------
[289] 174 390 1112 65 36 1195 995 914 75 1117 726 128
[[3]]
[1] FALSE FALSE FALSE FALSE TRUE FALSE TRUE FALSE FALSE TRUE
-------------------- lı́neas omitidas --------------------
[291] FALSE FALSE TRUE FALSE TRUE FALSE TRUE FALSE FALSE FALSE
> class(objeto_lista)
[1] "list"
> rm(a, b, c, n)
Aquı́ hemos creado un vector de la clase lista. Técnicamente una lista es

un vector, pero no un vector atómico (llamado ası́ porque sus elementos no
141
142 CAPÍTULO 13. LISTAS
pueden ser rotos en otros más básicos), sino que es un vector recursivo (llamado
ası́ porque sus elementos son listas) [101, 146].
Hjalmarson et al. [173] estudiaron el efecto del metoprolol frente a placebo
en la mortalidad después de un infarto agudo de miocardio medida 90 dı́as
después del infarto 1 .
> m <- matrix(c(62, 635, 40, 658), nr=2)

> dimnames(m) <- list(c(’Died’, ’Survived’),
+ c(’Placebo’, ’Metoprolol’))
> print(addmargins(m))
Placebo Metoprolol Sum
Died 62 40 102
Survived 635 658 1293
Sum 697 698 1395
Con la prueba ji cuadrado (χ2 = 4,697, df = 1, p = 0,030) se pone de

manifiesto que hay una asociación entre la mortalidad y el metoprolol, con
una menor mortalidad cuando se da este fármaco. Vemos que la salida de la
prueba en pantalla:
> (chi_test <- chisq.test(m))
Pearson’s Chi-squared test with Yates’ continuity

correction
data: m
X-squared = 4.6971, df = 1, p-value = 0.03021
es muy escueta, pero cuando analizamos el resultado de la función chisq.test(),

observamos que es una lista de nueve componentes.
> str(chi_test)
List of 9
$ statistic: Named num 4.7
..- attr(*, "names")= chr "X-squared"
$ parameter: Named int 1
..- attr(*, "names")= chr "df"
$ p.value : num 0.0302
$ method : chr "Pearson’s Chi-squared test with Yates’ continuity correction"
$ data.name: chr "m"
$ observed : num [1:2, 1:2] 62 635 40 658
..- attr(*, "dimnames")=List of 2
.. ..$ : chr [1:2] "Died" "Survived"
.. ..$ : chr [1:2] "Placebo" "Metoprolol"
1 The effect of metoprolol on mortality was compared with that of placebo in a double blind
randomised trial in patients with definite or suspected acute myocardial infarction. Treatment
with metoprolol or placebo started as soon as possible after the patient’s arrival in hospital and
was continued for 90 days. Metoprolol was given as a 15 mg intravenous dose followed by oral
administration of 100 mg twice daily. 1395 patients (697 on placebo and 698 on metoprolol) were
included in the trial. Definite acute myocardial infarction developed in 809 and probable infar-
ction in 162. Patients were allocated to various risk groups and within each group patients were
randomly assigned to treatment with metoprolol or placebo. There were 62 deaths in the placebo
group (8.9 %) and 40 deaths in the metoprolol group (5.7 %), a reduction of 36 % (p less than 0.03).
Mortality rates are given according to the treatment group to which the patients were initially
randomly allocated.

143
$ expected : num [1:2, 1:2] 51 646 51 647

www.editorialuc.es
$ residuals: num [1:2, 1:2] 1.546 -0.434 -1.545 0.434
$ stdres : num [1:2, 1:2] 2.27 -2.27 -2.27 2.27
- attr(*, "class")= chr "htest"
> rm(m, chi_test)
Las listas son colecciones ordenadas de objetos de cualquier tipo. Debido

a esta caracterı́stica son muy utilizadas como salida de funciones, para ofrecer
sus resultados.
La longitud de una lista es igual al número de componentes que tiene.
> length(chi_test)
[1] 9
A cada componente se puede acceder mediante el sistema de ı́ndices con

doble corchete [[x]] o mediante el operador $. La tendencia a cometer erro-
res es menor con el sistema de nombres (cuando los tiene) que el basado en
posiciones [146].
Ejemplo 13.1. ¿Cómo se puede acceder al valor de la p?.
> chi_test[[3]] # primer método

[1] 0.03021288
> chi_test$p.value # segundo método
[1] 0.03021288
Los corchetes sencillos dan el objeto que está en una determinada posición,
mientras que los corchetes dobles nos dan el contenido del objeto seleccionado,
por eso debemos utilizar los corchetes dobles (([[x]])) en vez de los sencillos
(([x])).
Ejemplo 13.2. Presente la tabla de datos observados y la tabla de datos es-

perados de la anterior prueba χ2 .
> chi_test$observed
Placebo Metoprolol
Died 62 40
Survived 635 658
> chi_test$expected
Placebo Metoprolol
Died 50.96344 51.03656
Survived 646.03656 646.96344

13.1. Crear
Las listas se crean con la función list(), incluyendo como argumentos
distintos objetos con nombre o sin él.
#---------------------------------------------------------------
list(...)
#---------------------------------------------------------------
Ejemplo 13.3. Cree una lista formada por un vector numérico con los núme-
ros del 1 al 20, un vector sin nombre con las seis primeras letras, una de
cadena de caracteres con tres nombres propios, una matriz cuadrada con los
primeros 25 números naturales y un data frame con dos variables numéri-
cas, la primera, llamada x, con los cinco primeros números naturales y la
segunda, llamada y, con los números del 50 al 46.
> lista <- list(a = 1:20,
+ letters[1:6],
+ c = c(’Juan’, ’Marta’, ’Elisa’),
+ d = matrix(1:25, nr = 5),
+ e = data.frame(x = 1:5, y = 50:46))
> lista
$a
[1] 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
[19] 19 20
[[2]]
[1] "a" "b" "c" "d" "e" "f"
$c
[1] "Juan" "Marta" "Elisa"
$d
[,1] [,2] [,3] [,4] [,5]
[1,] 1 6 11 16 21
[2,] 2 7 12 17 22
[3,] 3 8 13 18 23
[4,] 4 9 14 19 24
[5,] 5 10 15 20 25
$e
x y
1 1 50
2 2 49
3 3 48
4 4 47
5 5 46
13.2. Nombrar
Los nombres de los ((bin)) que forman la lista se pueden poner cuando se
crea la lista (como hemos visto en el ejemplo anterior) o posteriormente con la
función names().

13.3. INDEXAR 145
Ejemplo 13.4. El segundo objeto de la lista anterior no tiene nombre. póngale

el nombre ((b))
www.editorialuc.es
> names(lista) # segundo ’bin’ sin nombre
[1] "a" "" "c" "d" "e"
> names(lista)[2] <- ’b’ # se asigna nombre
> names(lista) # todos los objetos con nombre
[1] "a" "b" "c" "d" "e"
Los nombres de la lista se pueden eliminar con NULL.
Ejemplo 13.5. Cree una copia de la lista anterior y elimine los nombres de
sus componentes. Compruebe que los ha suprimido y elimine esta copia.
> lista2 <- lista # se hace una copia

> names(lista2) <- NULL # se eliminan los nombres
> names(lista2) # no hay nombres
NULL
> rm(lista2) # se elimina esta copia
13.3. Indexar
Una lista es como un tren de mercancı́as, cada componente es un vagón
del tren y cada vagón tiene su propio contenido [148], de manera que cuando
queramos acceder a un bin lo podemos hacer con los corchetes simples [bin],
pero cuando queremos acceder al contenido del bin emplearemos los corchetes
dobles [[número]] o si la lista tiene nombre, mediante $
> lista[1] # el primer ’bin’ (ver nombre)

$a
[1] 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
> lista[[1]] # contenido del primer ’bin’ (sin nombre)

[1] 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
> lista[[1]][3] # elemento 3 del primer ’bin’

[1] 3
> lista$a[3] # idem
[1] 3
> lista[1][3] # no funciona...
$<NA>
NULL
13.4. Reemplazar componentes de una lista

Para reemplazar un componente de una lista hay que referirse a él mediante
su etiqueta (tag) [146].
Ejemplo 13.6. Reemplace el segundo componente del objeto lista por otro
similar pero que contenga las mismas letras en mayúsculas.

> lista$b <- LETTERS[1:5]

> lista
$a
[1] 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
[19] 19 20
$b
[1] "A" "B" "C" "D" "E"
$c
$d
[,1] [,2] [,3] [,4] [,5]
[1,] 1 6 11 16 21
[2,] 2 7 12 17 22
[3,] 3 8 13 18 23
[4,] 4 9 14 19 24
[5,] 5 10 15 20 25
$e
x y
1 1 50
2 2 49
3 3 48
4 4 47
5 5 46
Ejemplo 13.7. Reemplace el valor 50 del data frame de la lista por 500. Vi-
sualice que ha hecho el cambio. Vuelva a cambiarlo a su valor original y
compruebe que lo ha hecho bien.
> lista$e$y[1] <- 500

> lista$e
x y
1 1 500
2 2 49
3 3 48
4 4 47
5 5 46
> lista[[5]][1,2]
[1] 500
> lista[[5]][1,2] <- 50
> lista$e
x y
1 1 50
2 2 49
3 3 48
4 4 47
5 5 46

13.5. OPERACIONES SOBRE UNA LISTA 147
13.5. Operaciones sobre una lista
www.editorialuc.es
Con una lista se pueden hacer operaciones, pero en general se utilizan po-
co debido a que la lista suele estar formada por elementos de distintos tipos,
por lo que es muy difı́cil que se quiera hacer lo mismo con cada uno de sus
componentes.
Se emplean dos funciones: lapply (list apply) y sapply (simplified apply):
lapply() aplica una función a cada uno de los componentes de la lista
y devuelve una lista.
sapply() aplica una función a cada uno de los componentes de la lista
y devuelve un vector.
Ejemplo 13.8. ¿Cuántos elementos tiene lista y qué longitud tiene cada
uno de ellos?
> length(lista)
[1] 5
> lapply(lista, length)
$a
[1] 20
$b
[1] 5
$c
[1] 3
$d
[1] 25
$e
[1] 2
Una forma más elegante es

> sapply(lista, length)
a b c d e
20 5 3 25 2
13.6. Eliminar
13.6.1. Eliminar la clase
La clase ((list)) se puede eliminar con la función unlist(), que convierte el
objeto lista en un vector atómico con todos los elementos de la lista.
#---------------------------------------------------------------
unlist(x, recursive = TRUE, use.names = TRUE)
#---------------------------------------------------------------
Ejemplo 13.9. Elimine la estructura ((lista)) del anterior objeto lista.

> (no_lista <- unlist(lista))

a1 a2 a3 a4 a5 a6 a7 a8
"1" "2" "3" "4" "5" "6" "7" "8"
a9 a10 a11 a12 a13 a14 a15 a16
"9" "10" "11" "12" "13" "14" "15" "16"
a17 a18 a19 a20 b1 b2 b3 b4
"17" "18" "19" "20" "A" "B" "C" "D"
b5 c1 c2 c3 d1 d2 d3 d4
"E" "Juan" "Marta" "Elisa" "1" "2" "3" "4"
d5 d6 d7 d8 d9 d10 d11 d12
"5" "6" "7" "8" "9" "10" "11" "12"
d13 d14 d15 d16 d17 d18 d19 d20
"13" "14" "15" "16" "17" "18" "19" "20"
d21 d22 d23 d24 d25 e.x1 e.x2 e.x3
"21" "22" "23" "24" "25" "1" "2" "3"
e.x4 e.x5 e.y1 e.y2 e.y3 e.y4 e.y5
"4" "5" "50" "49" "48" "47" "46"
Otra manera de conseguir el mismo efecto es utilizando el argumento op-

cional recursive = TRUE que controla si se produce un flattening cuando se
combinan listas recursivas [146]:
> c(lista, recursive = T)

a1 a2 a3 a4 a5 a6 a7 a8
"1" "2" "3" "4" "5" "6" "7" "8"
a9 a10 a11 a12 a13 a14 a15 a16
"9" "10" "11" "12" "13" "14" "15" "16"
a17 a18 a19 a20 b1 b2 b3 b4
"17" "18" "19" "20" "A" "B" "C" "D"
b5 c1 c2 c3 d1 d2 d3 d4
"E" "Juan" "Marta" "Elisa" "1" "2" "3" "4"
d5 d6 d7 d8 d9 d10 d11 d12
"5" "6" "7" "8" "9" "10" "11" "12"
d13 d14 d15 d16 d17 d18 d19 d20
"13" "14" "15" "16" "17" "18" "19" "20"
d21 d22 d23 d24 d25 e.x1 e.x2 e.x3
"21" "22" "23" "24" "25" "1" "2" "3"
e.x4 e.x5 e.y1 e.y2 e.y3 e.y4 e.y5
"4" "5" "50" "49" "48" "47" "46"
13.6.2. Eliminar un componente

De una lista se puede eliminar un componente simplemente declarándole
nulo (NULL).
Ejemplo 13.10. Elimine el quinto componente bin del objeto lista.
> lista[[5]] # el quinto componente (data frame)

x y
1 1 50
2 2 49
3 3 48
4 4 47
5 5 46

> lista_sin5 <- lista # copia

> lista_sin5[[5]] <- NULL # se elimina el data frame
www.editorialuc.es
> lista_sin5 # visualización de la nueva lista
$a
[1] 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
$b
[1] "A" "B" "C" "D" "E"
$c
$d
[,1] [,2] [,3] [,4] [,5]
[1,] 1 6 11 16 21
[2,] 2 7 12 17 22
[3,] 3 8 13 18 23
[4,] 4 9 14 19 24
[5,] 5 10 15 20 25
Es fácil comprobar cómo la lista original tiene cinco elementos y la nueva

solo 4:
> length(lista) # tiene 5 elementos

[1] 5
> length(lista_sin5) # tiene 4 elementos
[1] 4

Tabla:
Función Acción
addmargins() Marginales en una tabla
chisq.test() Prueba de ji cuadrado
dimnames() Pone nombre a un objeto
lapply() Aplica una función y devuelve una lista
matrix() Crea una función
names() Pone nombre a un objeto
print() Imprime en pantalla
rm() Remueve objetos
sample() Muestreo aleatorio
sapply() Aplica una función y simplifica
unlist() Elimina la estructura de una lista

PROBLEMAS
Problema 1. Compruebe que el objeto ((objeto lista)) creado anteriormente está for-
mado por tres componentes, cada uno de ellos de longitud 300.
Problema 2. Calcule la media del los datos contenidos en el segundo componente de
objeto lista utilizando únicamente una lı́nea de código.
Problema 3. ¿Es posible concatenar dos listas con la función c()? Demuéstrelo con
un ejemplo.
Problema 4. Si una lista está formada por tres vectores de longitud 10, 20 y 30
respectivamente, ¿cuál será la longitud de esa lista?

www.editorialuc.es
Capı́tulo 14
Matrices
14.1. Introducción
Se llama matriz a una disposición de elementos del mismo tipo en filas y
columnas. Es un vector con dos dimensiones. Una matriz numérica es un es-
quema formal de elementos de un conjunto numérico ordenados rectangular-
mente en filas y columnas [174]. En R una matriz es es un vector de datos que
tiene el atributo dim (dimensiones) especificando un doble ı́ndice [102].
Las matrices se representan con letras mayúsculas y con subı́ndices (filas y
columnas). Por ejemplo, Am×n se trata de la matriz A, que consta de m filas
y n columnas. Cada elemento se representa con una letra minúscula con dos
subı́ndices aij .
 
a11 a12 ... a1j ... a1n
 a21 a22 ... a2j ... a2n 
 
 a31 a32 ... a3j ... a3n 
 
A := 
 ... ... ... ... ... ...  
 ai1 ai2 ... aij ... ain 
 
 ... ... ... ... ... ... 
am1 am2 ... amj ... amn
Por ejemplo:
 
5 4 2 1
 2 3 1 −2 
M := 
 −5 −7 −3

9 
1 −2 −1 4
14.2. Creación
Las matrices se pueden crear de tres maneras:
14.2.1. Función matrix()

Utilizando la función matrix(). Se le deben pasar como primer argumen-
to el vector de datos (data =), después se especifica el número de filas (nrow
151
152 CAPÍTULO 14. MATRICES
=) y el número de columnas (ncol =) o al menos uno de estos dos, ya que R

calcula el otro, después, se le dice que los elementos los vaya colocando por
columnas (byrow = FALSE) o por filas (byrow = TRUE) y, finalmente, se le
pueden pasar los nombres de las filas y de las columnas).
#---------------------------------------------------------------
matrix(data = NA, nrow = 1, ncol = 1, byrow = FALSE,
dimnames = NULL)
#---------------------------------------------------------------
Ejemplo 14.1. Cree una matriz con los siguientes números: 5, 4, 2, 1, 5, 2, 3,

1, -2, -3, -5, -7, -3, 9, 16, 1, -2, -1, 4, 10. Ponga nombres a las filas: F1, F2, ... y a
las columnas: C1, C2, ....
> M <- matrix(c( 5, 4, 2, 1, 5,

+ 2, 3, 1, -2, -3,
+ -5, -7, -3, 9, 16,
+ 1, -2, -1, 4, 10),
+ nrow = 4,
+ ncol = 5,
+ byrow = TRUE,
+ dimnames = list(c(’F1’, ’F2’, ’F3’, ’F4’),
+ c(’C1’, ’C2’, ’C3’, ’C4’, ’C5’)))
> M
C1 C2 C3 C4 C5
F1 5 4 2 1 5
F2 2 3 1 -2 -3
F3 -5 -7 -3 9 16
F4 1 -2 -1 4 10
F4 1 -2 -1 4 10
No es necesario poner nombres a las filas o a las columnas. Cuando no se

hace, R pone los ı́ndices. Por ejemplo si quitamos los nombres, R escribe la
matriz con los ı́ndices:
> dimnames(M) <- NULL

> M
[,1] [,2] [,3] [,4] [,5]
[1,] 5 4 2 1 5
[2,] 2 3 1 -2 -3
[3,] -5 -7 -3 9 16
[4,] 1 -2 -1 4 10
> rm(M)
14.2.2. Función dim()

Otra forma de crear una matriz es dándole dos dimensiones a un vector,
pero siempre teniendo en cuenta que la longitud del vector debe ser igual al
producto de las dos dimensiones, de lo contrario R no sabe cómo crear la matriz
y da un error:
> dim(v) <- c(3, 3) # se le dan 2 dimensiones

> is.matrix(v) # es una matriz 3x3

14.2. CREACIÓN 153
[1] TRUE
> v # se visualiza
www.editorialuc.es
[,1] [,2] [,3]
[1,] 1 4 7
[2,] 2 5 8
[3,] 3 6 9
> # siempre length(v) == dim_1 x dim_2, si no ERROR

> v <- 1:11
> dim(v) <- c(3, 3) # 11 no es igual a 3x3 => ERROR
Error in dim(v) <- c(3, 3) :
dims [producto 9] no coincide con la longitud del objeto [11]
> rm(v)
14.2.3. Funciones cbind() y rbind()

La tercera manera de crear una matriz es juntando varios vectores para que
la formen. Esto se puede hacer con la función cbind() si queremos unirlos
((por columnas)) o con la función rbind() si queremos unirlos ((por filas)):
> (M <- cbind(v1, v2, v3)) # unión de 3 vectores por columnas

v1 v2 v3
[1,] 1 11 21
[2,] 2 12 22
[3,] 3 13 23
[4,] 4 14 24
[5,] 5 15 25
[6,] 6 16 26
> (N <- rbind(v1, v2, v3)) # unión de 3 vectores por filas
[,1] [,2] [,3] [,4] [,5] [,6]
v1 1 2 3 4 5 6
v2 11 12 13 14 15 16
v3 21 22 23 24 25 26
> rm(v1, v2, v3, M, N)
Los nombres de los vectores pasan a ser los nombres de las columnas si se
ha empleado cbind() o los nombres de las filas si se ha utilizado rbind().
Ejemplo 14.2. Lea el fichero vectores familias.RData y cree una matriz con
los vectores age, weight, height, waist, empleando la función cbind()
e imprı́malos en la consola de R.
> (M <- cbind(age, weight, height, waist))
age weight height waist
[1,] 42 78.0 173.0 89.2
[2,] 39 57.3 164.5 66.4
[3,] 13 42.7 156.3 60.1
------ lı́neas omitidas ------
[40,] 29 88.9 170.5 88.2
[41,] 22 70.3 160.3 69.0
[42,] 1 10.5 75.0 49.5

14.3. Manejo de una matriz

14.3.1. Poner y quitar nombres
En ocasiones interesa dar nombres a las filas o a las columnas o a ambos.
Esto se realiza con las funciones rownames(), colnames(), dimnames().
Por ejemplo, crearemos la matriz M, cuyos únicos atributos son la dimen-
sión. Tras dar nombre a las filas cambian los atributos, y en la visualización de
la matriz ya se observa que tiene nombres en las filas:
> (N <- matrix(1:12, nrow=3)) # creación
[,1] [,2] [,3] [,4]
[1,] 1 4 7 10
[2,] 2 5 8 11
[3,] 3 6 9 12
> attributes(N) # atributos: dimensión
$dim
[1] 3 4
> # nombres a FILAS

> rownames(N) <- c(’F1’, ’F2’, ’F3’)
> N
[,1] [,2] [,3] [,4]
F1 1 4 7 10
F2 2 5 8 11
F3 3 6 9 12
> attributes(N) # atributos: dimensión y nombre de filas
$dim
[1] 3 4
$dimnames
$dimnames[[1]]
[1] "F1" "F2" "F3"
$dimnames[[2]]
NULL
A continuación, daremos nombres a las columnas:

> colnames(N) <- paste(’C’, 1:4, sep=’’)
> N
C1 C2 C3 C4
F1 1 4 7 10
F2 2 5 8 11
F3 3 6 9 12
> attributes(N) # atributos: dimensión y nombres de fil y col
$dim
[1] 3 4
$dimnames
$dimnames[[1]]
[1] "F1" "F2" "F3"
$dimnames[[2]]
[1] "C1" "C2" "C3" "C4"

14.3. MANEJO DE UNA MATRIZ 155
Ejemplo 14.3. En el ejemplo anterior creó una matriz con la edad, peso, al-
tura y cintura de los miembros de las familias. Ponga nombres a las filas de
www.editorialuc.es
la matriz con los nombres de los sujetos.
> rownames(M) <- nom

> M
Pedro 42 78.0 173.0 89.2
Marı́a 39 57.3 164.5 66.4
Juan 13 42.7 156.3 60.1
-------- filas omitidas --------
Carmen 7 34.0 135.0 62.2
Emil 29 88.9 170.5 88.2
Isis 22 70.3 160.3 69.0
Casimiro 1 10.5 75.0 49.5
En muchas ocasiones interesa dar los nombres en un único paso con la fun-
ción dimnames(), que precisa que le pasemos –obligatoriamente– los nombres
en una lista y no en dos vectores.
Ejemplo 14.4. En un estudio de cohortes se encontró que enfermaron 23

sujetos de los 240 no expuestos al factor de estudio, mientras que enfermaron
416 de los 731 expuestos. Visualizar estos datos en una matriz.
> E <- matrix(c(23, 217, 416, 315), nrow = 2)

> dimnames(E) <- list(c(’Enfermo’, ’Sano’),
+ c(’No expuesto’, ’Expuesto’))
> E
No expuesto Expuesto
Enfermo 23 416
Sano 217 315
En otras ocasiones interesa eliminar los nombres de las filas, de las colum-
nas o ambos a la vez. Esto se realiza asignando NULL a los nombres de la di-
mensión que interese.
Ejemplo 14.5. Quite los nombres de las filas a la matriz M.
> rownames(M) <- NULL

> M
[1,] 42 78.0 173.0 89.2
[2,] 39 57.3 164.5 66.4
[3,] 13 42.7 156.3 60.1
--- filas omitidas ---
[40,] 29 88.9 170.5 88.2
[41,] 22 70.3 160.3 69.0
[42,] 1 10.5 75.0 49.5
Ejemplo 14.6. Quite los nombres de las filas y de las columnas a la matriz N.
> dimnames(N) <- NULL

> N

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

[1,] 1 4 7 10
[2,] 2 5 8 11
[3,] 3 6 9 12
14.3.2. Acceder a sus elementos

En una matriz puede interesar acceder a un elemento concreto. Esto se hace
((marcando)) las coordenadas de su posición dentro de la matriz (entre corche-
tes): Matriz[númeroDeFila, númeroDeColumna].
Ejemplo 14.7. Se desea calcular la odds ratio (OR) del estudio de cohortes
anterior en el que se creó la matriz E.
Como la OR es la razón de los productos cruzados [175], se necesita acceder a
cada uno de los elementos de la matriz:
> addmargins(E)
No expuesto Expuesto Sum
Enfermo 23 416 439
Sano 217 315 532
Sum 240 731 971
> or <- (E[1, 2] * E[2, 1] / (E[1, 1] * E[2, 2]))
> or # OR = 416 * 217 / (23 * 315)
[1] 12.4599
Cuando interesa acceder (o extraer) toda una fila se selecciona dejando el

ı́ndice de las columnas vacı́o (Matriz[númeroDeFila, ]) y cuando intere-
sa acceder a toda una fila se deja el ı́ndice de las columnas vacı́o (Matriz[,
númeroDeColumna]).
Cuando las filas o las columnas tienen nombres se puede acceder tanto por
el número como por el nombre, pero en este último caso debe ir entrecomillado
(Matriz["nombreDeFila", ], Matriz[, "nombreDeColumna"]).
Ejemplo 14.8. Continuando con el ejemplo del estudio de cohortes anterior,

se quiere extraer la fila de enfermos para ver cuántos estaban expuestos o no.
Igualmente se desea extraer la columna de los no expuestos para ver cuántos
enfermaron o no.
> E[’Enfermo’, ] # extracción de una fila (por nombre)

No expuesto Expuesto
23 416
> E[, 1] # extracción de una columna (por número)
Enfermo Sano
23 217
14.3.3. Eliminar una fila o una columna

Con el método recientemente comentado de acceder a una fila o a una co-
lumna es muy fácil eliminarla; simplemente con Matriz[-númeroDeFila/s,
] se elemina/n la fila o filas que se deseen. Igualmente para las columnas
Matriz[, -númeroDeColumna/s].

Ejemplo 14.9. Cree una matriz numérica de 7x5 con los primeros 35 núme-
ros naturales y a continuación elimine las filas 2 y 4 y después elimine las
www.editorialuc.es
columnas 1, 2, 6 y 7.
> (N <- matrix(c(1:35), nrow = 5))

[,1] [,2] [,3] [,4] [,5] [,6] [,7]
[1,] 1 6 11 16 21 26 31
[2,] 2 7 12 17 22 27 32
[3,] 3 8 13 18 23 28 33
[4,] 4 9 14 19 24 29 34
[5,] 5 10 15 20 25 30 35
> (N <- N[-c(2, 4), ]) # se eliminan las filas 2 y 4
[,1] [,2] [,3] [,4] [,5] [,6] [,7]
[1,] 1 6 11 16 21 26 31
[2,] 3 8 13 18 23 28 33
[3,] 5 10 15 20 25 30 35
> (N <- N[, -c(1, 2, 6, 7)]) # se eliminan las filas 1, 2, 6 y 7
[,1] [,2] [,3]
[1,] 11 16 21
[2,] 13 18 23
[3,] 15 20 25
14.3.4. Extraer una submatriz

Para extraer una submatriz se pueden eliminar filas o columnas como he-
mos visto en el apartado anterior, o se pueden seleccionar las filas o columnas
que interesen.
Ejemplo 14.10. Construya una matriz 7x5 como en el ejemplo anterior y

extraiga una matriz formada por las filas 1, 3 y 5 y por las columnas 3, 4 y 5.
¿Es igual al resultado del ejemplo anterior?
> N <- matrix(c(1:35), nrow = 5)

> N[c(1, 3, 5), 3:5]
[,1] [,2] [,3]
[1,] 11 16 21
[2,] 13 18 23
[3,] 15 20 25
14.3.5. Funciones exploradoras en matrices

Hay una serie de funciones que permiten conocer mejor determinadas ca-
racterı́sticas de una matriz (Tabla 14.1).
Supongamos un estudio de casos y controles en el que se observó que de los
35 sujetos con una determinada enfermedad presentaban un factor de riesgo
23, mientras que de los 93 sujetos sanos presentaban el factor de riesgo 15.
Cree una matriz con estos datos.
> A <- matrix(c(23, 25,

+ 12, 78), nrow = 2, byrow = TRUE)
> dimnames(A) <- list(c(’Factor’, ’No factor’),
+ c(’Enfermo’, ’Sano’))

Tabla 14.1: Funciones matriciales.

Función Acció
t(A) Traspuesta de la matriz A
row(A) Matriz del tamaño de A rellena con el número de filas
col(A) Matriz del tamaño de A rellena con el número de columnas
nrow(A) Número de filas de la matriz A
ncol(A) Número de columnas de la matriz A
diag(A) Diagonal principal de A o crea una matriz diagonal
det(A) Determinante de A
> addmargins(A)
Enfermo Sano Sum
Factor 23 25 48
No factor 12 78 90
Sum 35 103 138
Ejemplo 14.11. Calcule la matriz transpuesta de A.
> addmargins(t(A))
Factor No factor Sum
Enfermo 23 12 35
Sano 25 78 103
Sum 48 90 138
Ejemplo 14.12. Calcule el número de filas, de columnas, la diagonal princi-

pal y el determinante de la matriz A.
> nrow(A)
[1] 2
> ncol(A)
[1] 2
> diag(A)
[1] 23 78
> det(A)
[1] 1494
Ejemplo 14.13. Cree una matriz identidad de dimensión 7x7.
> diag(7)
[,1] [,2] [,3] [,4] [,5] [,6] [,7]
[1,] 1 0 0 0 0 0 0
[2,] 0 1 0 0 0 0 0
[3,] 0 0 1 0 0 0 0
[4,] 0 0 0 1 0 0 0
[5,] 0 0 0 0 1 0 0
[6,] 0 0 0 0 0 1 0
[7,] 0 0 0 0 0 0 1

Ejemplo 14.14. Cree una matriz diagonal cuya diagonal sea el vector 1:7.
www.editorialuc.es
> x <- 1:7
> diag(x, length(x))
[,1] [,2] [,3] [,4] [,5] [,6] [,7]
[1,] 1 0 0 0 0 0 0
[2,] 0 2 0 0 0 0 0
[3,] 0 0 3 0 0 0 0
[4,] 0 0 0 4 0 0 0
[5,] 0 0 0 0 5 0 0
[6,] 0 0 0 0 0 6 0
[7,] 0 0 0 0 0 0 7
Ejemplo 14.15. Cree una matriz diagonal 7x7 cuya diagonal principal sea el
número 8.
> x <- 1:7
> diag(8, length(x))
[,1] [,2] [,3] [,4] [,5] [,6] [,7]
[1,] 8 0 0 0 0 0 0
[2,] 0 8 0 0 0 0 0
[3,] 0 0 8 0 0 0 0
[4,] 0 0 0 8 0 0 0
[5,] 0 0 0 0 8 0 0
[6,] 0 0 0 0 0 8 0
[7,] 0 0 0 0 0 0 8
Ejemplo 14.16. En una matriz H formada por los 15 primeros números na-
turales, calcule la matriz triangular inferior.
> (H <- matrix(1:25, nrow = 5))
[,1] [,2] [,3] [,4] [,5]
[1,] 1 6 11 16 21
[2,] 2 7 12 17 22
[3,] 3 8 13 18 23
[4,] 4 9 14 19 24
[5,] 5 10 15 20 25
> lower.tri(H) # es igual que col(H) < row(H)
[,1] [,2] [,3] [,4] [,5]
[1,] FALSE FALSE FALSE FALSE FALSE
[2,] TRUE FALSE FALSE FALSE FALSE
[3,] TRUE TRUE FALSE FALSE FALSE
[4,] TRUE TRUE TRUE FALSE FALSE
[5,] TRUE TRUE TRUE TRUE FALSE
> H[lower.tri(H)]
[1] 2 3 4 5 8 9 10 14 15 20
> H[upper.tri(H)] <- NA
> H
[,1] [,2] [,3] [,4] [,5]
[1,] 1 NA NA NA NA
[2,] 2 7 NA NA NA
[3,] 3 8 13 NA NA
[4,] 4 9 14 19 NA
[5,] 5 10 15 20 25

Ejemplo 14.17. En una matriz H formada por los 15 primeros números na-
turales, calcule el vector que forma la matriz triangular superior.
> (H <- matrix(1:25, nrow = 5))

[,1] [,2] [,3] [,4] [,5]
[1,] 1 6 11 16 21
[2,] 2 7 12 17 22
[3,] 3 8 13 18 23
[4,] 4 9 14 19 24
[5,] 5 10 15 20 25
> (H[upper.tri(H)])
[1] 6 11 12 16 17 18 21 22 23 24
14.4. Cálculos en una matriz

Hay unas funciones muy útiles para realizar cálculos con los elementos de
una matriz (Tabla 14.2); unas calculan la suma de toda una fila (rowSums())
o de toda una columna (colSums()), otras calculan las medias de una fila
(rowMeans()) o de una columna (colMeans()).
Tabla 14.2: Funciones útiles en cálculos dentro de una matriz

Función Significado
rowSums() Suma de una fila matricial
colSums() Suma de una columna matricial
rowMeans() Media de una fila matricial
colMeans() Media de una columna matricial
Para explicar estas funciones vamos a utilizar un ejemplo:
Ejemplo 14.18. Se determinó la glucemia durante 5 dı́as seguidos a 7 mu-

jeres. Los valores obtenidos en la mujer 1 fueron {94, 78, 102, 87, 95} en la
mujer 2 {83, 91, 81, 84, 86}, mujer 3 {71, 78, 74, 84, 66}, mujer 4 {113, 99, 116,
121, 100}, mujer 5 {121, 114, 128, 132, 124}, mujer 6 {100, 102, 115, 107, 104} y
mujer 7 {80, 89, 78, 101, 92}. Introduzca los datos para crear una matriz de 7
filas (mujeres) y de 5 columnas (glucemias en ml/dL) cada uno de los 5 dı́as.
Ponga nombres a las filas y columnas. Calcule los totales de las filas y colum-
nas. Calcule también la glucemia media cada uno de los dı́as y la glucemia
media en cada una de las mujeres.
> # Primero se crean los vectores con las cifras de glucemia de

> # cada mujer en cada uno de los 5 dı́as
> mujer_1 <- c( 94, 78, 102, 87, 95)
> mujer_2 <- c( 83, 91, 81, 84, 86)
> mujer_3 <- c( 71, 78, 74, 84, 66)
> mujer_4 <- c(113, 99, 116, 121, 100)
> mujer_5 <- c(121, 114, 128, 132, 124)
> mujer_6 <- c(100, 102, 115, 107, 104)
> mujer_7 <- c( 80, 89, 78, 101, 92)

14.4. CÁLCULOS EN UNA MATRIZ 161
>
> # Se crea una matriz llamada G uniendo los vectores por filas
www.editorialuc.es
> G <- rbind(mujer_1, mujer_2, mujer_3, mujer_4,
+ mujer_5, mujer_6, mujer_7)
>
> # Se ponen nombres a las columnas (las filas ya lo tienen)
> colnames(G) <- paste(’dı́a’, 1:5, sep = ’_’)
>
> G # se visualiza la matriz
dı́a_1 dı́a_2 dı́a_3 dı́a_4 dı́a_5
mujer_1 94 78 102 87 95
mujer_2 83 91 81 84 86
mujer_3 71 78 74 84 66
mujer_4 113 99 116 121 100
mujer_5 121 114 128 132 124
mujer_6 100 102 115 107 104
mujer_7 80 89 78 101 92
> rowSums(G) # total filas
mujer_1 mujer_2 mujer_3 mujer_4 mujer_5 mujer_6 mujer_7
456 425 373 549 619 528 440
> colSums(G) # total columnas
662 651 694 716 667
> colMeans(G) # glucemia media cada uno de los dı́as
94.57143 93.00000 99.14286 102.28571 95.28571
> rowMeans(G) # glucemia media en cada mujer
91.2 85.0 74.6 109.8 123.8 105.6 88.
Hay una función interesante rowsum() que permite calcular sumas en las
matrices según un determinado factor.
Ejemplo 14.19. Suponga que en este estudio de la glucemia en las mujeres,

se conoce que las mujeres 1, 2, 3 y 7 tienen normopeso y las mujeres 4, 5 y 6
tienen sobrepeso. Podemos tener un vector peso <- c(0,0,0,1,1,1,0)
en el que 0 indica normopeso y 1 sobrepeso. Calcule si la glucemia a lo largo
de los dı́as es igual en las mujeres con peso normal o con peso elevado.
> peso <- factor(c(0, 0, 0, 1, 1, 1, 0),

+ labels = c(’normopeso’, ’sobrepeso’))
> (G1 <- rowsum(G, peso))
normopeso 328 336 335 356 339
sobrepeso 334 315 359 360 328
> G1[1, ] / 4 # glucemia promedio de las normopeso
82.00 84.00 83.75 89.00 84.75
> G1[2, ] / 3 # glucemia promedio de las mujeres con sobrepeso
111.3333 105.0000 119.6667 120.0000 109.3333
Se aprecia que cada dı́a la glucemia de las mujeres con sobrepeso es mayor
que en las que tienen normopeso.

Otra función que se utiliza mucho es apply(), que permite aplicar a una
matriz una función por un margen (filas o por columnas). Los argumentos son:
apply(matriz, margen, función). Ası́ para calcular la suma de las filas
(igual que con la función rowSums()) se harı́a con:
Ejemplo 14.20. Calcule la glucemia media de las mujeres con normopeso y

con sobrepeso (datos en la matriz G de los dos ejemplos previos).
> (media_glu <- apply(G, 1, mean))

91.2 85.0 74.6 109.8 123.8 105.6 88.0
> tapply(media_g, peso, mean)
normopeso sobrepeso
84.7000 113.0667
Una función útil es aquella que elimina las filas de una matriz que conten-
gan algún valor missing, como es la función nomiss() del paquete Hmisc.
Ejemplo 14.21. En la matriz M creada al principio de este capı́tulo con datos

de las familias hay missings en las filas 6, 13, 16 y 19. Elimine los missing de
la matriz M.
> M[c(6, 13, 16, 19), ]
[1,] NA NA NA NA
[2,] NA NA NA NA
[3,] 10 28.6 NA 50.5
[4,] 6 18.7 114 NA
> M1 <- Hmisc::nomiss(M)
> M1
[1,] 42 78.0 173.0 89.2
[2,] 39 57.3 164.5 66.4
[3,] 13 42.7 156.3 60.1
------ filas omitidas ------
[36,] 29 88.9 170.5 88.2
[37,] 22 70.3 160.3 69.0
[38,] 1 10.5 75.0 49.5
De la matriz M 42x4 se pasa a la matriz M1 38x4.
14.5. Operaciones con matrices

Hay muchas funciones para el manejo y trabajo con matrices, ya que éstas
son utilizadas en el cálculo estadı́stico, en el álgebra lineal, en la programa-
ción lineal, etc. Las funciones más utilizadas se recogen en la Tabla 14.3. Para el
producto matricial de la Matriz A y B, que sean conformables para la multipli-
cación, se utiliza A %* % B. Para el producto externo de dos vectores se emplea
v1 %o % v2 o la función outer(v1, v2, "*").
Par¡a poder probar estas funciones vamos a crear cuatro matrices: A matriz
x , B matriz x , C matriz x y D matriz x ,
> (A <- matrix(1:9, nrow = 3)) # 3x3

14.5. OPERACIONES CON MATRICES 163
Tabla 14.3: Funciones para el trabajo con matrices
www.editorialuc.es
Función Significado
t() traspuesta
det() determinante
diag(M) extrae la diagonal de la matriz M
diag(vector) crea una matriz diagonal
diag(n) crea una matriz identidad de tamaño n × n
eigen(M) crea una lista con autovalores y los autovectores de
una matriz cuadrada
svd(M) descomposición de la matriz M en valores singulares
solve() matriz inversa
[,1] [,2] [,3]

[1,] 1 4 7
[2,] 2 5 8
[3,] 3 6 9
> (B <- matrix(1:8, nrow = 4)) # 4x2
[,1] [,2]
[1,] 1 5
[2,] 2 6
[3,] 3 7
[4,] 4 8
> (C <- matrix(1:24, nrow = 6)) # 6x4
[,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
> (D <- matrix(1:12, nrow = 2)) # 2x6
[,1] [,2] [,3] [,4] [,5] [,6]
[1,] 1 3 5 7 9 11
[2,] 2 4 6 8 10 12
> (E <- matrix(c(9:1), nrow = 3)) # 3x3
[,1] [,2] [,3]
[1,] 9 6 3
[2,] 8 5 2
[3,] 7 4 1
14.5.1. Operaciones matemáticas elementales

Las operaciones matemáticas elementales son sencillas.
√
Ejemplo 14.22. Calcule A + 1, A − 2, A ∗ 3, A/4, A5 , A, log A.
> A + 1 # suma
[,1] [,2] [,3]
[1,] 2 5 8

[2,] 3 6 9
[3,] 4 7 10
> A - 2 # resta
[,1] [,2] [,3]
[1,] -1 2 5
[2,] 0 3 6
[3,] 1 4 7
> A * 3 # multiplicación
[,1] [,2] [,3]
[1,] 3 12 21
[2,] 6 15 24
[3,] 9 18 27
> A / 4 # división
[,1] [,2] [,3]
[1,] 0.25 1.00 1.75
[2,] 0.50 1.25 2.00
[3,] 0.75 1.50 2.25
> A ˆ 5 # potencia
[,1] [,2] [,3]
[1,] 1 1024 16807
[2,] 32 3125 32768
[3,] 243 7776 59049
> sqrt(A) # raı́z cuadrada
[,1] [,2] [,3]
[1,] 1.000000 2.000000 2.645751
[2,] 1.414214 2.236068 2.828427
[3,] 1.732051 2.449490 3.000000
> log(A) # logaritmo decimal
[,1] [,2] [,3]
[1,] 0.0000000 1.386294 1.945910
[2,] 0.6931472 1.609438 2.079442
[3,] 1.0986123 1.791759 2.197225
14.5.2. Multiplicación de dos vectores

En R los vectores son vectores columna, es decir, que si longitud es n, su
dimensión es (nx1), por lo que cuando R va a multiplicar dos vectores, al pre-
multiplicador le transpone para tener (1xn) * (nx1) = (1x1)
Ejemplo 14.23. Si x <- 1:10, calcule x*x, x’*x y x*x’, siendo x’ el tras-
puesto del vector original.
> x <- 1:10
> x % *% x # producto interno de dos vextores
[,1]
[1,] 385
> t(x) %*% x # traspuesto (1xn) por original (nx1)
[,1]
[1,] 385
>
> x %o% x # producto externo de dos vectores
[,1] [,2] [,3] [,4] [,5] [,6] [,7] [,8] [,9] [,10]
[1,] 1 2 3 4 5 6 7 8 9 10
[2,] 2 4 6 8 10 12 14 16 18 20

[3,] 3 6 9 12 15 18 21 24 27 30
[4,] 4 8 12 16 20 24 28 32 36 40
www.editorialuc.es
[5,] 5 10 15 20 25 30 35 40 45 50
[6,] 6 12 18 24 30 36 42 48 54 60
[7,] 7 14 21 28 35 42 49 56 63 70
[8,] 8 16 24 32 40 48 56 64 72 80
[9,] 9 18 27 36 45 54 63 72 81 90
[10,] 10 20 30 40 50 60 70 80 90 100
> x %*% t(x) # original (nx1) por traspuesto (1xn)
[,1] [,2] [,3] [,4] [,5] [,6] [,7] [,8] [,9] [,10]
[1,] 1 2 3 4 5 6 7 8 9 10
[2,] 2 4 6 8 10 12 14 16 18 20
[3,] 3 6 9 12 15 18 21 24 27 30
[4,] 4 8 12 16 20 24 28 32 36 40
[5,] 5 10 15 20 25 30 35 40 45 50
[6,] 6 12 18 24 30 36 42 48 54 60
[7,] 7 14 21 28 35 42 49 56 63 70
[8,] 8 16 24 32 40 48 56 64 72 80
[9,] 9 18 27 36 45 54 63 72 81 90
[10,] 10 20 30 40 50 60 70 80 90 100
>
> t(x) %*% t(x) # traspuesto (1xn) por traspuesto (1xn)
Error in t(x) %*% t(x) : argumentos no compatibles
> x == t(x) # verdadero
[,1] [,2] [,3] [,4] [,5] [,6] [,7] [,8] [,9] [,10]
[1,] TRUE TRUE TRUE TRUE TRUE TRUE TRUE TRUE TRUE TRUE
Vemos que R traspone o no al vector premultiplicador según convenga para

que la multiplicación sea coherente, de manera que xx es el producto interno
xT x, mientras que el producto externo (xxT ) se calcula con x %o % x [102].
14.5.3. Multiplicación de una matriz por un vector

Para realizar esta multiplicación se utiliza la función crossprod().
#---------------------------------------------------------------
crossprod(x, y = NULL)
tcrossprod(x, y = NULL)
#---------------------------------------------------------------
La función crossprod(X, y) calcula X T y de una manera más eficien-

te que t(X) %* % y. Si falta el segundo argumento, crossprod(X) calcula
X T X.
Ejemplo 14.24. Sea el vector x los números 1:10 y la matriz H (10x3) formada
por los primeros 30 números naturales. Calcule H’x y H’H.
> H <- matrix(1:30, nr=10)

> crossprod(H, x) # H’x
[,1]
[1,] 385
[2,] 935
[3,] 1485

> t(H) %*% x # H’x

[,1]
[1,] 385
[2,] 935
[3,] 1485
>
> crossprod(H) # H’H
[,1] [,2] [,3]
[1,] 385 935 1485
[2,] 935 2485 4035
[3,] 1485 4035 6585
> t(H) %*% H # H’H
[,1] [,2] [,3]
[1,] 385 935 1485
[2,] 935 2485 4035
[3,] 1485 4035 6585
14.5.4. Multiplicación de dos matrices

No todas las matrices se pueden multiplicar, solo se puede cuando el núme-
ro de las columnas de la primera matriz coincide con el número de las filas de la
segunda matriz; de lo contrario se dice que las dos matrices no son conformes
para la multiplicación.
Ejemplo 14.25. Calcule A ∗ B, C ∗ B. D ∗ C, B ∗ D, B ∗ D ∗ C
> A % *% B # 3x3 x 4x2 => no se puede

Error in A %*% B : argumentos no compatibles
> C % *% B # 6x4 x 4x2 = 6x2
[,1] [,2]
[1,] 130 290
[2,] 140 316
[3,] 150 342
[4,] 160 368
[5,] 170 394
[6,] 180 420
> D % *% C # 2x6 x 6x4 = 2x4
[,1] [,2] [,3] [,4]
[1,] 161 377 593 809
[2,] 182 434 686 938
> B % *% D # 4x2 x 2x6 = 4x6
[,1] [,2] [,3] [,4] [,5] [,6]
[1,] 11 23 35 47 59 71
[2,] 14 30 46 62 78 94
[3,] 17 37 57 77 97 117
[4,] 20 44 68 92 116 140
> B %*% D %*% C # 4x2 x 2x6 x 6x4 = 4x4
[,1] [,2] [,3] [,4]
[1,] 1071 2547 4023 5499
[2,] 1414 3358 5302 7246
[3,] 1757 4169 6581 8993
[4,] 2100 4980 7860 10740
El producto de dos matrices no es simétrico (habitualmente), de forma que

A ∗ B no es lo mismo que B ∗ A.

Ejemplo 14.26. ¿Es A*H = H*A?
www.editorialuc.es
> A % *% H
[,1] [,2] [,3]
[1,] 90 54 18
[2,] 114 69 24
[3,] 138 84 30
> H % *% A
[,1] [,2] [,3]
[1,] 30 84 138
[2,] 24 69 114
[3,] 18 54 90
No son iguales. La multiplicación no es conmutativa.
14.5.5. Matriz inversa

En el campo de las matrices cuadradas, una matriz inversa (A−1 ) es aquella
que multiplicada por la matriz original A da la matriz identidad, es decir que
A−1 A = AA−1 = I. En R se calcula con la función solve. Es importante saber
que no todas las matrices tienen inversa.
#---------------------------------------------------------------
solve(a, b, ...)
#---------------------------------------------------------------
Ejemplo 14.27. Calcule la matriz inversa de A, matriz cuadrada formada por

el vector c(3, -1, 2, 1, 0, 3, 0, 1, 1).
> (A <- matrix(c(3, -1, 2, 1, 0, 3, 0, 1, 1), nrow = 3))

[,1] [,2] [,3]
[1,] 3 1 0
[2,] -1 0 1
[3,] 2 3 1
> solve(A)
[,1] [,2] [,3]
[1,] 0.5 0.1666667 -0.1666667
[2,] -0.5 -0.5000000 0.5000000
[3,] 0.5 1.1666667 -0.1666667
Ejemplo 14.28. Calcule la matriz inversa de H.
> (H <- matrix(1:9, nrow = 3))

[,1] [,2] [,3]
[1,] 1 4 7
[2,] 2 5 8
[3,] 3 6 9
> solve(H)
Error in solve.default(H) :
Lapack routine dgesv: system is exactly singular: U[3,3] = 0

14.5.6. Sistemas de ecuaciones lineales

La función solve(A, b) resuelve el sistema de ecuaciones A %* % x = b,
si es que el sistema tiene solución.
Ejemplo 14.29. En un hospital han realizado tres pedidos: el primer pedido

(por 9936 euros) son 2 unidades del producto A, 6 unidades del producto B
y 13 unidades del producto C; el segundo pedido (por 5044 euros) consta de
13 unidades A, 4 B y 2 C; el tercer pedido (por 14760 euros) está formado por
16 A, 9 B y 15 C. El gerente de dicho hospital quiere saber cuánto vale cada
unidad de A, B y C.
> (A <- matrix(c(2, 6, 13,

+ 13, 4, 2,
+ 16, 9, 15), nrow = 3, byrow = TRUE))
[,1] [,2] [,3]
[1,] 2 6 13
[2,] 13 4 2
[3,] 16 9 15
> (b <- c(9936, 5044, 14760))
[1] 9936 5044 14760
> solve(A, b)
[1] 180 400 552

Tabla:
Función Acción
addmargins() Añade los marginales a una matriz
apply() aplica una función a una matriz por filas o por columnas
attributes() Muestra los atributos de un objeto
c() Crea objetos concatenando elementos
cbind() Une por columnas
colMeans() Calcula las medias de las columnas de una matriz
colnames() Asigna o muestra los nombres de las columnas
colSums() Calcula las sumas de laas columnas de una matriz
det() Calcula el determinante de una matriz
diag() Calcula la diagonal principal de una matriz
dim() Dimensiones de una matriz
dimnames() Asigna nombres a las filas y a las columnas de una ma-
triz
eigen() Calcula los eigenvalues
is.matrix() Comprueba si es una matriz
load() Lee un fichero de datos
matrix() Crea una matriz

Función Acción
nomiss() Elimina las filas que contienen algún NA
www.editorialuc.es
rbind() Une objetos por filas
rm() Remueve objetos de la memoria
rowMeans() Calcula las medias de las filas de una matriz
rownames() Nombres de las filas
rowsum() Calcula sumas de una matriz según un factor
rowSums() Calcula las sumas de laas filas de una matriz
solve() Calcula la inversa de una matriz o resuelve un sistema
de ecuaciones
svd() Calcula la descomposición singular de una matriz
t() Traspuesta de una matriz
tapply() Aplica una función a una matriz
PROBLEMAS
Problema 1. Resuelva el siguiente sistema de ecuaciones:
3x + 4y = 12
x + 2y = 8
Problema 2. Se tienen tres lingotes de 100 g cuya composición se presenta en la

tabla siguiente. ¿Qué peso habrá de tomarse de cada uno de los tres lingotes para
formar uno nuevo que contenga 42 g de oro, 57 g de plata y 51 g de cobre (ejemplo
tomado de Borbolla y Sanz [176]).
Lingote Oro Plata Cobre

1 20 30 50
2 30 40 30
3 40 50 10

www.editorialuc.es
Capı́tulo 15
Arrays
Una matriz es una disposición de elementos del mismo tipo en filas y co-
lumnas; es un vector con dos dimensiones. Los arrays también es una dispo-
sición ordenada de elementos de igual tipo, que si tienen dos dimensiones es
igual que una matriz, pero los arrays pueden tener más de dos dimensiones.
Por ejemplo, para almacenar una tabla 2x2 de un factor causal (expuesto y no
expuesto) y una variable resultado (sano o enfermo) se puede utilizar una ma-
triz. Pero si esta misma tabla es recogida teniendo en cuenta el sexo, en vez de
tener dos tablas, una para hombres y otra para mujeres, es mejor almacenar los
datos en un array con tres dimensiones: factor, resultado y sexo.
La mayorı́a de los paquetes estadı́sticos manejan un array o BdD a la vez.
R es capaz de manejar varios a la vez debido a que es un programa orientado
a los objetos.
15.1. Creación
Los array (un caso más general que las matrices) se crean con la función
array().
#---------------------------------------------------------------
array(data = NA, dim = length(data), dimnames = NULL)
#---------------------------------------------------------------
Ejemplo 15.1. Un ejemplo hipotético planteado por Armitage en su libro

[177] para hablar de los factores de confusión ofrece datos de 1000 casos y
1000 controles expuesto y no expuestos a un determinado factor, estratifica-
dos según sexo. La introducción de estos datos es muy fácil con un array.
> A <- array(data = c(160, 270, 240, 330,

+ 440, 320, 160, 80),
+ dim = c(2, 2, 2),
+ dimnames = list(c(’Enf’, ’Sano’),
+ c(’noExp’, ’Exp’),
+ c(’Varones’, ’Mujeres’)))
> A
, , Varones
171
172 CAPÍTULO 15. ARRAYS
noExp Exp
Enf 160 240
Sano 270 330
, , Mujeres
noExp Exp
Enf 440 160
Sano 320 80
> class(A)
[1] "array"
Los arrays tienen mucha utilidad en el análisis estratificado [170, 178–181].
Ejemplo 15.2. En el estudio Evans County se pretendı́a evaluar la posible

asociación entre la presencia de niveles altos de catecolaminas endógenas
(cat) y la coronariopatı́a (chd) en una cohorte de 609 varones blancos. Para
el análisis se estratificó en cuatro niveles (g1 = edad < 55 años y ecg normal,
g2 = edad < 55 años y ecg alterado, g3 = edad >= 55 años y ecg normal y
g4 = edad >= 55 y ecg alterado). Los datos, tomados del libro Epidemiologic
Research (pág 334) de Kleinbaum et al. son: c(1, 7, 17, 257, 3, 14, 7, 52, 9, 30, 15,
107, 14, 44, 5, 27). Cree un array y rotúlelo adecuadamente.
> evans <- array(c(1, 7, 17, 257,

+ 3, 14, 7, 52,
+ 9, 30, 15, 107,
+ 14, 44, 5, 27),
+ dim = c(2, 2, 4),
+ dimnames = list(c(’chd’, ’No chd’),
+ c(’cat’, ’No cat’),
+ c(’age < 55, ecg = 0’,
+ ’age < 55, ecg = 1’,
+ ’age 55+, ecg = 0’,
+ ’age 55+, ecg = 1’)))
> addmargins(evans)
, , age < 55, ecg = 0
cat No cat Sum

chd 1 17 18
No chd 7 257 264
Sum 8 274 282
, , age < 55, ecg = 1
cat No cat Sum

chd 3 7 10
No chd 14 52 66
Sum 17 59 76
, , age 55+, ecg = 0
cat No cat Sum

15.2. OPERACIONES CON ARRAYS 173
chd 9 15 24
No chd 30 107 137
www.editorialuc.es
Sum 39 122 161
, , age 55+, ecg = 1
cat No cat Sum

chd 14 5 19
No chd 44 27 71
Sum 58 32 90
, , Sum
cat No cat Sum

chd 27 44 71
No chd 95 443 538
Sum 122 487 609
15.2. Operaciones con arrays

Al ser los arrays una generalización de las matrices su manejo es similar,
es decir, se utiliza el sistema de ı́ndices, etc. Por ejemplo, addmargins() im-
prime los marginales cuando se imprime un array, como hemos visto en el
ejemplo anterior.
Ejemplo 15.3. Calcule los riesgos relativos en cada uno de los cuatro estratos
del array evans.
> rr <- numeric(4)

> for (i in 1:4) {
+ rr[i] <- prop.table(evans[, , i], 2)[1, 1] /
+ prop.table(evans[, , i], 2)[1, 2]
+ }
> round(rr, 2)
[1] 2.01 1.49 1.88 1.54
En ocasiones interesa permutar las dimensiones, para ello está la función

aperm().
#---------------------------------------------------------------
aperm(a, perm = NULL, resize = TRUE, ...)
#---------------------------------------------------------------
Ejemplo 15.4. Permute las dimensiones 1 y 3 del array evans.
> aperm(evans, c(3,2,1))

, , chd
cat No cat
age < 55, ecg = 0 1 17
age < 55, ecg = 1 3 7
age 55+, ecg = 0 9 15
age 55+, ecg = 1 14 5

174 CAPÍTULO 15. ARRAYS
, , No chd
cat No cat
age < 55, ecg = 0 7 257
age < 55, ecg = 1 14 52
age 55+, ecg = 0 30 107
age 55+, ecg = 1 44 27

Tabla:
Función Acción
addmargins() Añade los marginales cuando se imprime un array
aperm() Permuta las dimensiones de un array
array() Crea un array
prop.table() Proporciones en una tabla, por filas o por columnas
PROBLEMAS
Problema 1. Selvin [182] en su libro Statistical Tools for Epidemiologic Re-
search, página 45, presenta los datos (en tablas 2x2) de bajo peso al nacer (< 2500 g)
y hábito tabáquico en las madres, estratificado según etnia/raza (blancas, afroamerica-
nas, hispanas, y asiáticas) con los siguientes datos: c(98, 169, 832, 3520, 54, 55, 227,
686, 11, 61, 85, 926, 7, 90, 102, 1936). Se le pide que cree un array con estos datos,
lo imprima en la consola y -suponiendo que fuera un estudio prospectivo- calcule en
qué estrato hay mayor riesgo relativo.
Problema 2. Con los datos del estudio ((Evans County)), calcule la OR en cada
estrato sabiendo que la OR es la rezan de los productos cruzados.
Problema 3. En el estudio ((Evans County)), ¿qué estrato tiene la OR con el valor
más elevado?, ¿son simulares los valores de OR y RR?

www.editorialuc.es
Capı́tulo 16
Data frames
En cualquier investigación se definen unas variables de interés cuyos datos

se recogen en cada uno de los sujetos sometidos a estudio. Estos datos pueden
ser de diferentes tipos: datos cualitativos, cuantitativos, de fecha, lógicos, etc.
El investigador precisa archivarlos en alguna estructura que le permita una
adecuada depuración y posterior análisis para describirlos y contrastar la/s
hipótesis del estudio. Para esto no se deben utilizar múltiples vectores (serı́an
difı́ciles de manejar), ni matrices (todos los datos son del mismo tipo), sino que
el investigador necesita una estructura que tenga una disposición de tabla, en
la que en cada fila queden recogidas las observaciones de cada individuo y en
cada columna los datos correspondientes a cada una de las variables. Para esto
necesita utilizar una base de datos (BdD).
R dispone de una estructura especial, llamada dataframe que permite alma-
cenar datos de diferentes caracterı́sticas.
16.1. Creación
La manera más sencilla de crear una BdD con la función data.frame()
que permite unir varios vectores en una BdD.
#---------------------------------------------------------------
data.frame(..., row.names = NULL, check.rows = FALSE,
check.names = TRUE, fix.empty.names = TRUE,
stringsAsFactors = default.stringsAsFactors())
#---------------------------------------------------------------
Ejemplo 16.1. En el capı́tulo sobre ((vectores)), tabla 10.1, se presentó una dis-
posición rectangular de datos que sirvieron para crear una serie de vectores:
id, family, relative, nom, age, alive, sex, weight, height, waist.
Utilicemos la función data.frame() para crear un dataframe.
> df <- data.frame(id, family, relative, nom, age, alive,
+ sex, weight, height, waist)
> df
175
176 CAPÍTULO 16. DATA FRAMES
1 1 F1 padre Pedro 42 TRUE M 78.0 173.0 89.2

2 2 F1 madre Marı́a 39 TRUE F 57.3 164.5 66.4
------------------------ filas omitidas ------------------------
42 42 F10 hijo1 Casimiro 1 TRUE M 10.5 75.0 49.5
16.2. Lectura
La manera más eficiente, y por tanto la más utilizada, para recuperar una
BdD y poderla analizar es con la función read.table(). Hay otras funciones
disponibles, como vamos a ver a continuación. Se utilizará una u otra en virtud
de las caracterı́sticas de los datos almacenados que queramos recuperar.
16.2.1. La función read.table()

#---------------------------------------------------------------
read.table(file, header = FALSE, sep = "", quote = "\"’",
dec = ".", row.names, col.names,
as.is = !stringsAsFactors,
na.strings = "NA", colClasses = NA, nrows = -1,
skip = 0, check.names = TRUE,
fill = !blank.lines.skip,
strip.white = FALSE, blank.lines.skip = TRUE,
comment.char = "#",
allowEscapes = FALSE, flush = FALSE,
stringsAsFactors = default.stringsAsFactors(),
fileEncoding = "", encoding = "unknown")
#---------------------------------------------------------------
Datos separados por un espacio

Para leer un fichero que esté en formato texto, con los datos separados
por espacios en blanco, se utilizan los parámetros file = ’fichero.txt’,
header = TRUE, as.is = TRUE que deja las cadenas como cadenas:
> df1 <- read.table(file = ’bd_Familias_p.txt’,

+ header = TRUE,
+ as.is = TRUE)
> str(df1)
’data.frame’: 42 obs. of 10 variables:
$ id : int 1 2 3 4 5 6 7 8 9 10 ...
$ family : chr "F1" "F1" "F1" "F1" ...
$ relative: chr "padre" "madre" "hijo1" "hijo2" ...
$ nom : chr "Pedro" "Marı́a" "Juan" "Lucı́a" ...
$ age : int 42 39 13 12 9 NA 3 37 34 7 ...
$ alive : logi TRUE TRUE TRUE TRUE TRUE FALSE ...
$ sex : chr "M" "F" "M" "F" ...
$ weight : num 78 57.3 42.7 38.3 27.7 NA 14.6 86.9 62.5 ...
$ height : num 173 164 156 148 130 ...
$ waist : num 89.2 66.4 60.1 53.2 54.6 NA 48.3 93 68.5 ...
> head(df1, 3)

16.2. LECTURA 177

www.editorialuc.es
3 3 F1 hijo1 Juan 13 TRUE M 42.7 156.3 60.1
Si solo se pasan dos parámetros file = ’fichero.txt’, header =

TRUE, read.table() convierte las cadenas en factores. Esta suele ser la op-
ción más utilizada:
> df2 <- read.table(file = ’bd_Familias_p.txt’,

+ header = TRUE)
> str(df2)
$ id : int 1 2 3 4 5 6 7 8 9 10 ...
$ family : Factor w/ 10 levels "F1","F10","F2",..: 1 1 1 1 1 1
$ relative: Factor w/ 7 levels "hijo1","hijo2",..: 7 6 1 2 3 4
$ nom : Factor w/ 32 levels "Alberto","Ana",..: 30 21 16 18
$ age : int 42 39 13 12 9 NA 3 37 34 7 ...
$ sex : Factor w/ 2 levels "F","M": 2 1 2 1 2 2 1 2 1 1 ...
$ weight : num 78 57.3 42.7 38.3 27.7 NA 14.6 86.9 62.5 ...
$ height : num 173 164 156 148 130 ...
$ waist : num 89.2 66.4 60.1 53.2 54.6 NA 48.3 93 68.5 48 ...
> head(df2)
3 3 F1 hijo1 Juan 13 TRUE M 42.7 156.3 60.1
4 4 F1 hijo2 Lucı́a 12 TRUE F 38.3 147.6 53.2
5 5 F1 hijo3 Marcos 9 TRUE M 27.7 130.2 54.6
6 6 F1 hijo4 Miguel NA FALSE M NA NA NA
Si los números están con la coma decimal en vez del punto, la lectura será in-
correcta, porque R convierte los vectores numéricos en cadenas (por tanto los
leerá como factores) y sus NA pasan a <NA>.
> df3 <- read.table(file = ’bd_Familias_c.txt’,

+ header = TRUE)
> str(df3)
$ id : int 1 2 3 4 5 6 7 8 9 10 ...
$ age : int 42 39 13 12 9 NA 3 37 34 7 ...
$ weight : Factor w/ 38 levels "10,5","13,2",..: 30 21 15 13 10
$ height : Factor w/ 36 levels "101,3","102,6",..: 25 19 11 7 5
$ waist : Factor w/ 34 levels "43,2","44","45",..: 32 21 16 10
> head(df3)
1 1 F1 padre Pedro 42 TRUE M 78 173 89,2
2 2 F1 madre Marı́a 39 TRUE F 57,3 164,5 66,4
3 3 F1 hijo1 Juan 13 TRUE M 42,7 156,3 60,1

4 4 F1 hijo2 Lucı́a 12 TRUE F 38,3 147,6 53,2

5 5 F1 hijo3 Marcos 9 TRUE M 27,7 130,2 54,6
6 6 F1 hijo4 Miguel NA FALSE M <NA> <NA> <NA>
Para leerlo bien deberemos especificar que los decimales están con comas
pasando otro parámetro (dec=’,’) a la función read.table():
> df4 <- read.table(file = ’bd_Familias_c.txt’,

+ header = TRUE,
+ dec = ’,’)
> str(df4)
$ id : int 1 2 3 4 5 6 7 8 9 10 ...
$ age : int 42 39 13 12 9 NA 3 37 34 7 ...
$ weight : num 78 57.3 42.7 38.3 27.7 NA 14.6 86.9 62.5 ...
$ height : num 173 164 156 148 130 ...
$ waist : num 89.2 66.4 60.1 53.2 54.6 NA 48.3 93 68.5 48 ...
> head(df4)
3 3 F1 hijo1 Juan 13 TRUE M 42.7 156.3 60.1
Datos separados por tabuladores

Para leer un fichero que esté en formato texto, con los datos separados por
tabuladores, se utilizan los parámetros file = ’fichero.txt’, header
= TRUE, sep = ’\t’:
> df5 <- read.table(file = ’bd_Familias_t.txt’,

+ header = TRUE,
+ sep = ’\t’)
> str(df5)
$ id : int 1 2 3 4 5 6 7 8 9 10 ...
$ age : int 42 39 13 12 9 NA 3 37 34 7 ...
$ weight : num 78 57.3 42.7 38.3 27.7 NA 14.6 86.9 62.5 23 ...
$ height : num 173 164 156 148 130 ...
$ waist : num 89.2 66.4 60.1 53.2 54.6 NA 48.3 93 68.5 48 ...
> head(df5)

16.2. LECTURA 179

www.editorialuc.es
3 3 F1 hijo1 Juan 13 TRUE M 42.7 156.3 60.1
16.2.2. La función read.csv()

#---------------------------------------------------------------
read.csv(file, header = TRUE, sep = ",", quote="\"", dec=".",
fill = TRUE, comment.char="", ...)
read.csv2(file, header = TRUE, sep = ";", quote="\"", dec=",",

#---------------------------------------------------------------
Esta es la opción que más se suele utilizar, ya que en la mayor parte de

los casos lo datos los suele tener el investigador en hojas de cálculo. Antes de
leerlos hay que grabarlos en formato csv (valores separados por comas). La
lectora se realiza con la función read.csv(). Los argumentos son similares a
los de read.table():
> df6 <- read.csv(file = ’bd_Familias.csv’,

+ header = TRUE,
+ sep = ’;’, dec=’,’)
> str(df6)
$ id : int 1 2 3 4 5 6 7 8 9 10 ...
$ age : int 42 39 13 12 9 NA 3 37 34 7 ...
$ weight : num 78 57.3 42.7 38.3 27.7 NA 14.6 86.9 62.5 23 ...
$ height : num 173 164 156 148 130 ...
$ waist : num 89.2 66.4 60.1 53.2 54.6 NA 48.3 93 68.5 48 ...
> head(df6)
3 3 F1 hijo1 Juan 13 TRUE M 42.7 156.3 60.1
16.2.3. Otras funciones de lectura

Hay otras funciones de lectura de datos (Tabla 16.1) que no comentaremos.
Únicamente veremos cómo se llaman estas funciones.
%#---------------------------------------------------------------

Tabla 16.1: Las funciones de lectura de datos en RR
Función Acción
read.arff() Lee datos en formato ARFF (Weka Attribute-Relation
File Format
read.csv2() Lee datos en formato cdv adaptado al español
read.dbf() Lee datos en formato dBase
read.DIF() Lee datos en formato DIF (Data Interchange Format)
read.dta() Lee datos en formato Stata
read.epiinfo() Lee datos en formato EpiInfo
read.fortran() Lee datos en formato Fortran
read.ftable() Lee datos en formato tablas planas
read.fwf() Lee datos en formato fijo
read.mtp() Lee datos en formato Minitab
read.octave() Lee datos en formato Octave
read.spss() Lee datos en formato SPSS
read.ssd() Lee datos en formato SAS
read.systat() Lee datos en formato Systat
read.xport() Lee datos en formato SAS-Xport
read.delim(file, header = TRUE, sep = "\t", quote="\"", dec=".",

read.delim2(file, header = TRUE, sep = "\t", quote="\"", dec=",",

read.dbf(file, as.is = FALSE)
read.DIF(file, header = FALSE,

dec = ".", row.names, col.names,
as.is = !stringsAsFactors,
na.strings = "NA", colClasses = NA, nrows = -1,
skip = 0, check.names = TRUE,
blank.lines.skip = TRUE,
stringsAsFactors = default.stringsAsFactors(),
transpose = FALSE)
read.dta(file, convert.dates = TRUE, convert.factors = TRUE,

missing.type = FALSE,
convert.underscore = FALSE, warn.missing.labels = TRUE)
read.epiinfo(file, read.deleted = FALSE, guess.broken.dates = FALSE,

thisyear = NULL, lower.case.names = FALSE)
read.fortran(file, format, ..., as.is = TRUE, colClasses = NA)
read.ftable(file, sep = "", quote = "\"",

row.var.names, col.vars, skip = 0)

16.3. DIVISIÓN DE UNA BASE DE DATOS (SUBMUESTRAS) 181
read.fwf(file, widths, header = FALSE, sep = "\t",

skip = 0, row.names, col.names, n = -1,
www.editorialuc.es
buffersize = 2000, ...)
read.mtp(file)
read.octave(file)
read.spss(file, use.value.labels = TRUE, to.data.frame = FALSE,

max.value.labels = Inf, trim.factor.names = FALSE,
trim_values = TRUE, reencode = NA,
use.missings = to.data.frame)
read.ssd(libname, sectionnames,
tmpXport=tempfile(), tmpProgLoc=tempfile(), sascmd="sas")
read.systat(file, to.data.frame = TRUE)
read.xport(file)
%#---------------------------------------------------------------
16.3. División de una base de datos (submuestras)

En ocasiones para el análisis estadı́stico se necesita seleccionar a un grupo
determinado de sujetos. Esto se puede hacer de varias formas.
Ejemplo 16.2. De la lectura efectuada con read.csv() creó la BdD df6;

seleccione una submuestra formada solo por las madres.
> df7 <- df6[df6$relative == ’madre’, ]

> df7
9 9 F2 madre Marta 34 TRUE F 62.5 161.6 68.5
12 12 F3 madre Carmen 26 TRUE F 58.0 162.0 64.0
15 15 F4 madre Mónica 42 TRUE F 67.0 159.0 77.0
18 18 F5 madre Paz 37 TRUE F 61.5 159.5 66.0
23 23 F6 madre Andrea 32 TRUE F 61.5 159.0 66.0
27 27 F7 madre Marina 32 TRUE F 61.4 169.0 76.0
35 35 F9 madre Gloria 34 TRUE F 56.7 165.5 70.5
41 41 F10 madre Isis 22 TRUE F 70.3 160.3 69.0
Ejemplo 16.3. De la BdD de las familias df6 seleccione una submuestra

formada por 10 sujetos seleccionados aleatoriamente.
> set.seed(2016)
> (df8 <- df6[sample(df6$id, 10), ])
8 8 F2 padre Luis 37 TRUE M 86.9 172.5 93.0

34 34 F9 padre Pepe 37 TRUE M 81.0 174.0 89.5

19 19 F5 hijo1 Dolores 6 TRUE F 18.7 114.0 NA
23 23 F6 madre Andrea 32 TRUE F 61.5 159.0 66.0
32 32 F8 hijo1 Juan 13 TRUE M 42.9 156.8 60.3
16.4. Mezcla de bases de datos

En ocasiones el investigador desea unir BdD. Para unir diferentes BbD con
un campo común se utiliza la función merge().
%#---------------------------------------------------------------
merge(x, y, by = intersect(names(x), names(y)),
by.x = by, by.y = by, all = FALSE, all.x = all, all.y = all,
sort = TRUE, suffixes = c(".x",".y"), incomparables = NULL,
...)
%#---------------------------------------------------------------
Ejemplo 16.4. Supongamos que, además de la BdD df6 con los datos de
las familias, tenemos otra BdD de los mismos sujetos (aunque nos faltan los
datos de dos familias) en la que hemos registrado la ciudad en la que viven
y en nivel de colesterol total (mg/dL). Queremos unir las dos BdD (llamadas
df6 y df9) en una única llamada df10.
> df9 <- read.csv(’bd_FamiliasCiudad.csv’,

+ header = TRUE, sep = ’;’, dec = ’,’)
> str(df9, 2)
$ id : int 1 2 3 4 5 6 7 8 9 10 ...
$ ciudad: Factor w/ 5 levels "Barcelona","Bilbao",..: 4 4 4 4 4 4 4 1 1
$ ct : int 220 176 175 154 180 166 158 192 220 187 ...
> df10 <- merge(df6, df9, all = TRUE)
> head(df10)
id family relative nom age alive sex weight height waist ciudad ct
1 1 F1 padre Pedro 42 TRUE M 78.0 173.0 89.2 Madrid 220
2 2 F1 madre Marı́a 39 TRUE F 57.3 164.5 66.4 Madrid 176
3 3 F1 hijo1 Juan 13 TRUE M 42.7 156.3 60.1 Madrid 175
4 4 F1 hijo2 Lucı́a 12 TRUE F 38.3 147.6 53.2 Madrid 154
5 5 F1 hijo3 Marcos 9 TRUE M 27.7 130.2 54.6 Madrid 180
6 6 F1 hijo4 Miguel NA FALSE M NA NA NA Madrid 166
16.5. Caracterı́sticas de un data frame

Para estudiar las caracterı́sticas de un data frame vamos a trabajar con la
BdD PimaESP.xls que hemos visto en el apartado anterior.
Las principales caracterı́sticas de una BdD son [91, 161]:

16.5. CARACTERÍSTICAS DE UN DATA FRAME 183
16.5.1. Dimensiones
Las dimensiones de una BdD se exploran con la función dim(). Devuelve
www.editorialuc.es
dos valores, el primero corresponde al número de filas y el segundo al de las
columnas.
Ejemplo 16.5. ¿Qué dimensiones tiene la BdD Pima.csv?
> dim(DF)
[1] 632 9
El resultado de explorar la BdD con la función dim() [632 9] nos está indi-
cando que es una BdD que contiene 632 registros y 9 variables.
16.5.2. Estructura
La estructura de un DF se explora con la función str(). Es muy impor-
tante cuando uno comienza a trabajar con una BdD el conocer su estructura,
qué variables contiene, cómo se llaman, de qué tipo son, etc.
Ejemplo 16.6. ¿Qué estructura tiene la BdD Pima.csv?

> str(DF)
$ Id : int 1 2 3 4 5 6 7 8 9 10 ...
$ npreg: int 4 1 0 4 9 4 5 8 3 0 ...
$ glu : int 151 71 84 144 72 97 139 85 115 101 ...
$ bp : int 90 78 82 58 78 60 64 55 66 62 ...
$ skin : int 38 50 31 28 25 23 35 20 39 NA ...
$ bmi : num 29.7 33.2 38.2 29.5 31.6 28.2 28.6 24.4 38.1 21.9 ...
$ ped : num 0.294 0.422 0.233 0.287 0.28 0.443 0.411 0.136 0.15 0.336 ...
$ age : int 36 21 23 37 38 22 26 42 28 25 ...
$ type : Factor w/ 2 levels "No","Yes": 1 1 1 1 1 1 1 1 1 1 ...
Aunque la BdD o data frame pertenece a la clase ((data frame)), su tipo es

un lista, tal y como dijimos anteriormente:
> class(DF)
[1] "data.frame"
> typeof(DF)
[1] "list"
Por ser una lista podemos utilizar el operador $, por lo que para acceder a
una variable deberemos teclear DF$variable:
> DF$bp
[1] 90 78 82 58 78 60 64 55 66 62 70 90 62 96 52
[16] 88 72 72 70 82 76 90 78 74 85 NA 72 70 70 88
------------------------ filas omitidas ------------------------
[601] 84 40 56 62 74 64 50 64 64 30 68 78 78 62 66
[616] 64 76 56 84 50 88 90 86 60 74 60 74 84 46 88
[631] 70 78
Ejemplo 16.7. ¿Cuál es la estructura de la BdD que acabamos de crear (la

df10)?

> str(df10)
$ id : int 1 2 3 4 5 6 7 8 9 10 ...
$ age : int 42 39 13 12 9 NA 3 37 34 7 ...
$ weight : num 78 57.3 42.7 38.3 27.7 NA 14.6 86.9 62.5 23 ...
$ height : num 173 164 156 148 130 ...
$ waist : num 89.2 66.4 60.1 53.2 54.6 NA 48.3 93 68.5 48 ...
$ ciudad : Factor w/ 5 levels "Barcelona","Bilbao",..: 4 4 4 4
$ ct : int 220 176 175 154 180 166 158 192 220 187 ...
16.5.3. Variables
Las variables son las columnas del DF. Su nombre puede ponerse de mani-
fiesto con la función names().
Ejemplo 16.8. ¿Cómo se llaman las variables de la BdD Pima.csv?

> names(DF)
[1] "Id" "npreg" "glu" "bp" "skin" "bmi" "ped" "age"
[9] "type"
16.5.4. Registros
Los registros se refieren a cuántos casos o sujetos hay en la BdD. Habitual-
mente hay un registro por persona. Ya veremos que en los estudios longitudi-
nales hay más de un registro por cada uno de los sujetos participantes.
Ejemplo 16.9. ¿Cuántos registros hay en la BdD Pima.csv?

> dim(DF)[1]
[1] 632
16.5.5. Otros atributos

Los data frames también pueden tener otros atributos. Lo habitual es que no
los tengan , pero cuando se importan desde otros programas que sı́ los manejan
(Stata, etc.) nos los podemos encontrar.
Etiqueta de la BdD ((datalabel))

Las BdD puede tener una etiqueta que explique someramente en qué con-
siste. Cuando utilicemos la función des() veremos que imprime en consola
dicha etiqueta (si es que existe).
Como la etiqueta es un atributo más del data frame, la podemos crear fácil-
mente con la función attr():
Ejemplo 16.10. Ponga una etiqueta a la BdD de las indias Pima con el si-
guiente texto: ((Diabetes y factores asociados en indias Pima (1988)))

16.6. DEPURACIÓN DE UNA BDD 185
> etiqueta <- ’Diabetes y factores asociados en indias Pima (1988)’

> attr(DF, ’datalabel’) <- etiqueta
www.editorialuc.es
> des(DF)
Diabetes y factores asociados en indias Pima (1988)
No. of observations = 632
Variable Class Description
1 Id numeric
2 Nemb numeric
3 Glup numeric
4 TAD numeric
5 Ptri numeric
6 IMC numeric
7 Fpdia numeric
8 Edad numeric
9 Diab factor
Fecha de creación ((time.stamp))

En ocasiones conviene dejar constancia de la fecha de creación de la BdD:
Ejemplo 16.11. Ponga la fecha en que etiquetó la BdD anterior: ((12ago2016

12:30)).
> attr(DF, ’time.stamp’) <- ’12ago2016 12:30’
> attributes(DF)$time.stamp
[1] "12 Ago 2010 12:30"
Versión de la BdD ((version))

También puede interesarnos dejar la versión:
Ejemplo 16.12. Ponga también la versión de la BdD anterior: ((1.02)).
> attr(DF, ’version’) <- 1.02

> attributes(DF)$version
[1] 1.02
16.6. Depuración de una BdD

Cuando se trabaja con una BdD, el trabajo de preparar correctamente los
datos para el análisis estadı́stico es complejo y consume tiempo. Unas veces
habrá que eliminar los registros con datos ausentes, otras ordenar la BdD, co-
rregir datos, erróneos, eliminar duplicados, etc. Cómo resolver estas situacio-
nes se explica a continuación:
16.6.1. Ordenar una BdD

Para ordenar un data frame por una variable:
DF[order(var), ]
DF[rev(order(var)), ].
Para ordenar un data frame por varias variables:

DF[order(var1, var2, var3, ...), ].
Ejemplo 16.13. Ordene la BdD de las familias ((df6)) por el peso y la altura.
> df6[order(weight, height), ]

28 28 F7 hijo1 Juan 1 TRUE M 8.7 74.0 43.2
29 29 F7 hijo2 Pablo 1 TRUE M 9.3 75.5 44.0
42 42 F10 hijo1 Casimiro 1 TRUE M 10.5 75.0 49.5
------------------------ filas omitidas ------------------------
30 30 F8 padre Gabriel 42 TRUE M 78.8 173.8 85.2
34 34 F9 padre Pepe 37 TRUE M 81.0 174.0 89.5
17 17 F5 padre Paco 38 TRUE M 82.0 176.0 85.0
22 22 F6 padre Alberto 36 TRUE M 82.0 176.0 45.0
8 8 F2 padre Luis 37 TRUE M 86.9 172.5 93.0
40 40 F10 padre Emil 29 TRUE M 88.9 170.5 88.2
13 13 F3 hijo1 <NA> NA FALSE F NA NA NA
16.6.2. Seleccionar casos

Para seleccionar casos con un determinado valor en una variable:
DF[var == valor, ]
DF[var >condición, ]
DF[var1 >valor1 & var2 == valor2, ]
Ejemplo 16.14. Seleccione los casos con sexo femenino.
> df6[df6$sex == ’F’, ]

7 7 F1 hijo5 Clara 3 TRUE F 14.6 97.5 48.3
------------------------ filas omitidas ------------------------
38 38 F9 hijo3 Pilar 14 TRUE F 48.0 152.0 53.3
39 39 F9 hijo4 Carmen 7 TRUE F 34.0 135.0 62.2
Ejemplo 16.15. Seleccione los varones con una cintura superior a 90 cm.
> df[df6$sex == ’M’ & df$waist > 90, ]

NA NA <NA> <NA> <NA> NA NA <NA> NA NA NA
8 8 F2 padre Luis 37 TRUE M 86.9 172.5 93
No se tienen que seleccionar los casos con NA en la cintura:
> df[df6$sex == ’M’ & df$waist > 90 & !is.na(df$waist), ]

8 8 F2 padre Luis 37 TRUE M 86.9 172.5 93

16.7. RESUMIENDO EL CONTENIDO DE UNA BDD 187
16.6.3. Trabajar con columnas de una BdD

Para extraer todas las columnas que contienen números:
www.editorialuc.es
DF[, sapply(DF, is.numeric)]
Para extraer todas las columnas que son un factor:
DF[, sapply(DF, is.factor)]
Para extraer todas las columnas que son factores:
DF[, sapply(DF, is.character)]
Ejemplo 16.16. ¿Hay alguna variable de caracteres en la BdD df6?

> df6[, sapply(df6, is.character)]
data frame with 0 columns and 42 rows
16.6.4. Trabajar con filas de una BdD

Para eliminar determinadas filas:
DF[-(filas), ]
Para eliminar todas las filas que no tienen un determinado valor en una varia-
ble:
DF[!(var == valor), ]
DF[-which(var == valor), ]
DF[!(var == valor), ]
Para eliminar filas que contienen missing:
newDF <- na.omit(DF)
newDF <- na.exclude(DF)
complete.cases(DF)
DF[complete.cases(DF), ]
Ejemplo 16.17. En la BdD df6 con los datos de las familias, ¿cuántos regis-
tros completos hay?.
> sum(complete.cases(df6))
[1] 38
16.6.5. Trabajar con los missing de una BdD

Para ver el número de missing en todas las variables de un DF:
apply(apply(DF, 2, is.na), 2, sum)
Para ver el número de missing en una variable de un DF:
summary(DF$var)
Ejemplo 16.18. ¿Cuántos NA hay en la BdD ((df6))?

> sum(apply(apply(df6, 2, is.na), 2, sum))
[1] 11
16.7. Resumiendo el contenido de una BdD

La función summary() tiene mucha utilidad en una primera exploración
de los datos.

Ejemplo 16.19. Resuma la BdB ampliada de las familias df10.
> summary(df10)
id family relative nom
Min. : 1.00 F1 : 7 hijo1:10 Juan : 4
1st Qu.:11.25 F9 : 6 hijo2: 6 Carmen : 2
Median :21.50 F5 : 5 hijo3: 4 José : 2
Mean :21.50 F6 : 5 hijo4: 2 Marı́a : 2
3rd Qu.:31.75 F8 : 4 hijo5: 1 Marina : 2
Max. :42.00 F10 : 3 madre:10 (Other):29
(Other):12 padre: 9 NA’s : 1
age alive sex weight
Min. : 1.00 Mode :logical F:21 Min. : 8.70
1st Qu.: 6.75 FALSE:2 M:21 1st Qu.:21.93
Median :15.00 TRUE :40 Median :50.75
Mean :20.60 NA’s :0 Mean :47.67
3rd Qu.:36.25 3rd Qu.:67.83
Max. :42.00 Max. :88.90
NA’s :2 NA’s :2
height waist ciudad ct
Min. : 74.0 Min. :43.20 Barcelona: 3 Min. :132.0
1st Qu.:119.0 1st Qu.:48.90 Bilbao : 4 1st Qu.:164.0
Median :159.0 Median :60.30 Burgos : 5 Median :176.0
Mean :143.4 Mean :62.66 Madrid : 7 Mean :188.3
3rd Qu.:167.2 3rd Qu.:73.25 Santander:14 3rd Qu.:200.0
Max. :178.0 Max. :93.00 NA’s : 9 Max. :280.0
NA’s :3 NA’s :3 NA’s :9
También se puede utilizar la función aggregate() para cálculos especı́fi-

cos:
#---------------------------------------------------------------
## S3 method for class ’data.frame’
aggregate(x, by, FUN, ..., simplify = TRUE, drop = TRUE)
## S3 method for class ’formula’

aggregate(formula, data, FUN, ...,
subset, na.action = na.omit)
#---------------------------------------------------------------
Ejemplo 16.20. Se quiere calcular la edad media de los padres, las madres,
los hijos primogénitos y los que han nacido en 2o , 3o , 4o y 5o lugar.
> with(df10, aggregate(age, by = list(relative),

+ mean, na.rm = TRUE))
Group.1 mean.age
1 hijo1 7.777778
2 hijo2 7.666667
3 hijo3 7.500000
4 hijo4 7.000000
5 hijo5 3.000000
6 madre 33.700000
7 padre 36.777778

www.editorialuc.es
Tabla:
Función Acción
aggregate() Aplica una función a un dataframe.
apply() Aplica una función a un dataframe.
complete.cases() Selecciona casos sin NA.
data.frame() Crea un dataframe.
head() Primeros 6 registros de una dataframe.
load() Lee un fichero.
merge() Une dos BdD.
na.exclude() Elimina casos con NA.
na.omit() Elimina casos con NA.
order() Ordena una BdB.
read.csv() Lee un fichero csv.
read.table() Lee una BdD en varios formatos.
rev() invierte el orden.
sample() Muestreo aleatorio.
sapply() Aplica una función a una BdD.
set.seed() Semilla de aleatorización.
str() Estructura de un objeto R.
summary() Resumen de un objeto.
which() Identifica según una condición.
with () Hace accesibles las variables de una BdD.
PROBLEMAS
Problema 1. ¿Cuántos registros completos hay en la BdD df Pima.csv?

www.editorialuc.es
Capı́tulo 17
Tiempo en R
El tiempo es una variable numérica continua que los humanos manejamos

bastante mal o, por lo menos, con dificultad, pese a que es muy utilizado en
estudios epidemiológicos y en análisis de supervivencia.
Con esta variable casi nunca empleamos el sistema métrico decimal, actual-
mente denominado Sistema Internacional (SI). Los años tienen una duración
variable por los bisiestos, los meses duran de 28 a 31 dı́as, los años no empie-
zan siempre en el mismo dı́a de la semana, los dı́as no duran exactamente 86400
segundos ya que, debido al efecto de las mareas, hay segundos intercalares, el
dı́a sidéreo dura 4 minutos menos que el dı́a solar, la hora legal no coincide
con la hora local, etc.
En el uso de la edad tampoco se utiliza el SI, siempre referimos la edad
como el número entero de los años cumplidos. En español las fechas las expre-
samos en sentido creciente (dı́a, mes y año), mientras que el tiempo en sentido
decreciente (horas, minutos y segundos). Tampoco las horas tienen un único
valor, en el que el origen es el meridiano terrestre de Greenwich (GMT, de
Greenwich Mean Time), sino que cada huso horario en que se divide la Tierra
tiene su propia hora (zona horaria), y en algunos husos se cambia según ho-
rario de verano o de invierno. Los militares y en aeronáutica emplean la hora
zulú (que es una hora común y no la hora local).
La unidad de tiempo es el segundo (s) calculado como una media ponde-
rada de las señales de relojes atómicos de 70 laboratorios distribuidos por todo
el mundo. Se llama Tiempo Universal Coordinado (UTC).
Pese a estos problemas comentados R maneja adecuadamente el tiempo. El
origen en R (the epoch) es el 1 de enero de 1970 a las 12:00 h. Es es tiempo 0; a
partir de ahı́, hacia adelante se cuentan los segundos transcurridos en sentido
positivo y hacia atrás en sentido negativo. Por ejemplo, el 20 de junio de 2016
son
En el tiempo podemos distinguir dos aspectos importantes: a) fechas y
tiempos. Las fechas se refieren a dı́as meses y años, mientras que los tiempos
se refieren a horas, minutos, segundos.
191
192 CAPÍTULO 17. TIEMPO EN R
Figura 17.1: Husos horarios en el mudo https://en.wikipedia.org/wiki/

Coordinated_Universal_Time.
17.1. Clases
Varias son las clases relacionadas con el tiempo (Tabla 17.1). La clase ((Date))
es la más sencilla pues son fechas. La clase ((POSIXct)) mide el tiempo como
algo continuo (en segundos desde un origen), mientras que la clase ((POSIXlt))
lo expresa como una lista con varios componentes separados [183].
Tabla 17.1: Clases de objetos de tiempo.
Clase Significado
POSIXct Fechas + horas (tiempo continuo)
POSIXlt Fechas, Horas (lista de tiempo)
Date Fechas
difftime Diferencias de tiempo (con unidades)
17.2. Exploración del tiempo actual

R dispone de varias funciones para obtener el tiempo actual del sistema.
17.2.1. La función Sys.timezone()

Esta función nos dice qué huso horario tiene nuestro ordenador. Tiene poca
utilidad.
#---------------------------------------------------------------
Sys.timezone(location = TRUE)
#---------------------------------------------------------------

17.2. EXPLORACIÓN DEL TIEMPO ACTUAL 193
Ejemplo 17.1. ¿Cuál es nuestro huso horario (time zone)?
www.editorialuc.es
> Sys.timezone()
[1] "Europe/Madrid"
17.2.2. La función Sys.time()

Cuando se ejecuta esta función devuelve un objeto (de las clases POSIXct
y POSIXt) con la fecha y hora actuales, reflejo de los segundos transcurridos
desde el origen (epoch).
#---------------------------------------------------------------
Sys.time()
#---------------------------------------------------------------
Ejemplo 17.2. Suponga que son las 18:37:00 del 11 de junio de 2016. ¿Qué in-
formación sobre la fecha y hora tiene el sistema?
> (a <- Sys.time()) # fecha y hora actual

[1] "2016-06-11 18:37:00 CEST"
> class(a) # clase POSIXct y POSIXt
[1] "POSIXct" "POSIXt"
> unclass(a) # segundos transcurridos
[1] 1465663020
Presenta el tiempo ordenado en sentido decreciente, primero la fecha ((año-

mes-dia)), después la hora ((horas-minutos-segundos)) y después la zona ho-
raria ((CEST)) (zona europea). Este objeto pertenece a dos clases ((POSIXct)) y
((POSIXt)). Cuando se quita la clase aparece un número 1465663020 que corres-
ponde a los segundos que han transcurrido desde las 12:00:00 del 1 de enero
de 1970.
Del objeto que devuelve Sys.time() es fácil obtener la fecha y la hora con
la función substr().
Ejemplo 17.3. De la fecha del problema anterior extraiga dos cadenas, una
con la fecha y otra con la hora.
> (fecha <- substr(a, 1, 10))

[1] "2016-06-12"
> class(fecha)
[1] "character"
> (hora <- substr(a, 12, 19))
[1] "06:38:35"
> class(hora)
[1] "character"
17.2.3. La función Sys.Date()

Esta función devuelve un objeto (de la clase ((Date))) con la fecha actual.
Cuando se elimina la clase aparece un número que corresponde a los dı́as trans-
curridos desde el 1 de enero de 1970.

#---------------------------------------------------------------
Sys.Date()
#---------------------------------------------------------------
Ejemplo 17.4. ¿Qué información contiene el objeto creado con la función

Sys.Date()?
> (b <- Sys.Date()) # fecha actual

[1] "2016-06-11"
> class(b) # clase Date
[1] "Date"
> unclass(b) # dı́as transcurridos
[1] 16963
17.2.4. La función date()

Esta función devuelve un objeto (de la clase ((character))) con la fecha y ho-
ra actuales. Presenta el dı́a de la semana, el mes, el dı́a del mes en número,
horas:minutos:segundos y el año.
#---------------------------------------------------------------
date()
#---------------------------------------------------------------
Ejemplo 17.5. ¿Qué información contiene el objeto creado con la función

date()?
> (c <- date()) # fecha-hora en caracteres

[1] "Sat Jun 11 19:27:17 2016"
> class(c)
[1] "character"
17.3. Conversión de cadenas de caracteres en fechas

17.3.1. La función as.Date()
La función as.Date() convierte cadenas de caracteres en fechas. El for-
mato por defecto es " %Y- %m- %d", pero se puede especificar otro según nos
interese.
#---------------------------------------------------------------
as.Date(x, format, ...)
#---------------------------------------------------------------
> hoy_c <- "2016-06-11" # cadena con la fecha actual

> class(hoy_c) # ((character))
[1] "character"
> hoy_d <- as.Date(hoy_c) # convierte en fecha
> class(hoy_d) # ((Date))
[1] "Date"

17.3. CONVERSIÓN DE CADENAS DE CARACTERES EN FECHAS 195
Tabla 17.2: Formatos de fechas.
www.editorialuc.es
Cadena Significado
%d Dı́a del mes (01–31)
%m Mes del año en número (01–12)
%b Nombre abreviado del mes
%B Nombre completo del mes
%y Año sin siglo, por ejemplo 16
%Y Año con siglo, por ejemplo 2016
%H Horas del dı́a (00–23) en reloj con formato de 24 horas
%I Horas del dı́a (01–12) en reloj con formato de 12 horas
%p Indicador AM/PM
%M Minutos (00–59)
%S Segundos (00–61)
%U Semana del año (00-53) utilizando el primer domingo como dı́a 1
%W Semana del año (00–53), el primer lunes es el dı́a 1
%a Nombre abreviado del dı́a de la semana
%A Nombre completo del dı́a de la semana
%w Dı́a de la semana (0–6)
%j Dı́a del año (001–366)
Para convertir una cadena de caracteres en una fecha cuando la cadena no

está en el formato por defecto hay que incluir el parámetro format, de acuerdo
con los códigos que se presentan en la Tabla 17.2.
Ejemplo 17.6. Convierta la cadena ”11-06-2016” en una fecha.
> x <- ’11-06-2016’

> (x <- as.Date(x, format = ’%d-%m-%Y’))
[1] "2016-06-11"
> class(x)
[1] "Date"
Ejemplo 17.7. Convierta la cadena ”12/06/16” en una fecha.
> y <- ’12/06/16’

> (y <- as.Date(y, format = ’%d/%m/%y’))
[1] "2016-06-12"
> y - x
Time difference of 1 days
Ejemplo 17.8. Convierta la cadena ”11jun2016” en una fecha.
> z <- ’11jun2016’

> (z <- as.Date(y, format = ’%d/%b/%Y’))
[1] "2016-06-12"

17.3.2. La función ISOdatetime()

Esta función crea fechas a partir de representaciones numéricas.
#---------------------------------------------------------------
ISOdatetime(year, month, day, hour, min, sec, tz = "")
#---------------------------------------------------------------
Ejemplo 17.9. Cree un objeto fecha con los siguientes datos numéricos: año
2016, mes 06, dia 11, hora 21, minutos 20 y segundos 11.
> (d <- ISOdatetime(2016, 06, 11, 21, 20, 13))

[1] "2016-06-11 21:20:13 CEST"
> class(d)
[1] "POSIXct" "POSIXt"
17.4. Operaciones con fechas y horas

17.4.1. Sumas y restas
Un objeto fecha admite que se le pueda sumar o restar un número, pero
solo admite que se le pueda restar otra fecha.
> x <- as.Date(’2016-06-12’)

> y <- as.Date(’2016-04-12’)
>
> x + 10 # suma 10 dı́as
[1] "2016-06-22"
> x - 10 # resta 10 dı́as
[1] "2016-06-02"
> x * 2 # multiplicación no permitida
Error in Ops.Date(x, 2) : * not defined for "Date" objects
>
> x - y # resta dos fechas
Time difference of 61 days
> x + y # suma dos fechas no permitida
Error in ‘+.Date‘(x, y) : binary + is not defined for "Date" objects
17.4.2. La función difftime()

Esta función devuelve un objeto (de la clase ((difftime))) con la diferencia
entre dos fechas.
#---------------------------------------------------------------
difftime(time1, time2, tz,
units = c("auto", "secs", "mins", "hours",
"days", "weeks"))
#---------------------------------------------------------------
Ejemplo 17.10. Un sujeto que nació el 12 de febrero de 1998 acude a un

hospital con un cuadro de abdomen agudo el 31 de mayo de 2016. ¿Qué edad
tiene?

17.4. OPERACIONES CON FECHAS Y HORAS 197
> fnac <- ’12/02/1998’

> fing <- ’31/05/2016’
www.editorialuc.es
> fnac <- as.Date(fnac, format = ’%d/%m/%Y’)
> fing <- as.Date(fing, format = ’%d/%m/%Y’)
> edad <- as.numeric((fing - fnac) / 365.25)
> edad
[1] 18.29706
También se podı́a haber calculado ası́:
> as.numeric(difftime(fing, fnac)) / 365.25

[1] 18.29706
Ejemplo 17.11. ¿Cuanto tiempo ha transcurrido desde las 7:2:20 hasta las
14:21:35 del mismo dı́a.
> x1 <- ISOdatetime(year = 2016, month = 06, day = 12,

+ hour = 7, min = 2, sec = 20)
> x2 <- ISOdatetime(year = 2016, month = 06, day = 12,
+ hour = 14, min = 21, sec = 35)
> x2 - x1
Time difference of 7.320833 hours
> rm(x1, x2)
Se podrı́a haber calculado de una manera más sencilla empleando la fun-

ción as.difftime().
> # más sencillo

> x3 <- as.difftime(’7:2:20’)
> x4 <- as.difftime(’14:21:35’)
> x4 - x3
Time difference of 7.320833 hours
> rm(x3, x4)
17.4.3. Generación de secuencias

En ocasiones se necesitan secuencias de tiempo. Es fácil crearlas con la fun-
ción seq().
Ejemplo 17.12. Genere una secuencia entre el 14 de mayo de 2010 y el 28 de

septiembre de 2016: 1) cada 3 dı́as, 2) cada 2 semanas, 3) cada 3 trimestres y
4) cada año.
> origen <- as.Date(’2010-05-14’)

> final <- as.Date(’2016-09-28’)
> (seq_1 <- seq(origen, final, ’3 days’))

[1] "2010-05-14" "2010-05-17" "2010-05-20" "2010-05-23"
----------------------- filas omitidas -----------------------
[769] "2016-09-03" "2016-09-06" "2016-09-09" "2016-09-12"
[773] "2016-09-15" "2016-09-18" "2016-09-21" "2016-09-24"
[777] "2016-09-27"

> (seq_2 <- seq(origen, final, ’2 weeks’))

[1] "2010-05-14" "2010-05-28" "2010-06-11" "2010-06-25"
----------------------- filas omitidas -----------------------
[161] "2016-07-01" "2016-07-15" "2016-07-29" "2016-08-12"
[165] "2016-08-26" "2016-09-09" "2016-09-23"
> (seq_3 <- seq(origen, final, ’3 quarters’))

[1] "2010-05-14" "2011-02-14" "2011-11-14" "2012-08-14"
[5] "2013-05-14" "2014-02-14" "2014-11-14" "2015-08-14"
[9] "2016-05-14"
> (seq_4 <- seq(origen, final, ’1 year’))

[1] "2010-05-14" "2011-05-14" "2012-05-14" "2013-05-14"
[5] "2014-05-14" "2015-05-14" "2016-05-14"
Hay más funciones que se pueden utilizar y un paquete recomendable:

lubridate [184], además del paquete timeDate aún en desarrollo.
17.5. Uso de fechas en Bases de Datos

En Ciencias de la Salud es muy frecuente utilizar fechas u horas en BdD.
Cuando se lee una BdD convierte las cadenas de caracteres en factores, excepto
que se haya tenido la precaución de declarar el parámetro stringsAsFactor
= TRUE. Para explicar, de una manera sencilla, cómo de debe trabajar con tiem-
pos vamos a utilizar el siguiente ejemplo:
Ejemplo 17.13. Se está haciendo determinada tarea cuyo resultado puede

ser positivo o negativo. El 20 de junio de 2016 se hacen tres tareas, la primera
dura 1h 20m 13s (positivo), la segunda 1h 1m 2s (positivo) y la tercera 56m
13s (positivo); al dı́a siguiente se hacen otras tres tareas, la primera dura 1h
43m 17s (negativo), la segunda 1h 25m 0s (positivo) y la tercera 1h 18m 20s
(negativo). Introduzca los datos en un data frame y calcule la duración total
de cada tarea en segundos.
> min <- c(20, 1, 56, 43, 25, 18)

> seg <- c(13, 2, 13, 17, 0, 20)
> res <- c(rep(’positivo’, 3), ’negativo’, ’positivo’,
+ ’negativo’)
> df <- data.frame(id, fecha, hora, min, seg, res,
+ stringsAsFactors = FALSE)
> df
id fecha hora min seg res
1 1 20-06-2016 1 20 13 positivo
2 2 20-06-2016 1 1 2 positivo
3 3 20-06-2016 0 56 13 positivo
4 4 21-06-2016 1 43 17 negativo
5 5 21-06-2016 1 25 0 positivo
6 6 21-06-2016 1 18 20 negativo
Ahora hay que convertir las cadenas de caracteres de fecha en fechas y los
tres vectores de horas, minutos y segundos en tiempo.

> df$fecha <- as.Date(df$fecha, format = ’%d-%m-%Y’)

> df$dura <- as.difftime(
www.editorialuc.es
+ paste(df$hora, df$min, df$seg, sep = ’:’),
+ units = ’secs’)
> df
id fecha hora min seg res dura
1 1 2016-06-20 1 20 13 positivo 4813 secs
2 2 2016-06-20 1 1 2 positivo 3662 secs
3 3 2016-06-20 0 56 13 positivo 3373 secs
4 4 2016-06-21 1 43 17 negativo 6197 secs
5 5 2016-06-21 1 25 0 positivo 5100 secs
6 6 2016-06-21 1 18 20 negativo 4700 secs
La duración de la prueba osciló entre 3373 y 6197 segundos.

Tabla:
Función Acción
as.Date() Convierte una cadena en fecha.
as.difftime() Convierte una cadena en tiempo.
date() Fecha actual.
difftime() Diferencia entre dos fechas.
format() Distintos formatos de tiempo.
ISOdatatime() Convierte números en fechas.
months() Mes de una fecha.
quarters() Trimestre de una fecha.
seq() Genera una secuencia.
substr() Extrae una subcadena.
summary() Resume un vector.
Sys.Date() Fecha del ordenador.
Sys.time() Fecha y hora del sistema.
Sys.timezone() Huso horario del sistema.
weekdays() Dı́a de la semana.
as.POSIXct() Convierte en tiempo continuo.
as.POSIXlt() Convierte en lista de tiempo.
PROBLEMAS
Problema 1. ¿Cómo se llaman las variables que almacenan fecha y tiempo utilizando
la clase POSIXlt?
Problema 2. ¿Qué valores tienen estas variables hoy?

Problema 3. Introduzca le fecha y hora en que empezó a leer este libro. ¿Cuántos
segundos hace de ello?
Problema 4. ¿Qué dı́a de la semana es hoy?
Problema 5. ¿En qué trimestre del año estamos?
Problema 6. ¿Cómo se llama el mes actual?
Problema 7. ¿Cuántos segundos ha vivido usted?

www.editorialuc.es
Capı́tulo 18
Fórmulas en R
Una clase especial de objetos en R son las fórmulas, que se emplean para
poner de manifiesto relaciones entre variables.
18.1. Declaración
Las fórmulas se declaran con el sı́mbolo ∼ que separa dos partes, la del lado
izquierdo que corresponde a las variables dependientes y la del lado derecho
que corresponde a las variables independientes. Por ejemplo: y ˜ x, significa
que y es modelada en función de x, o que y depende de x.
18.1.1. Sı́mbolos empleados en las fórmulas

Además del sı́mbolo utilizado en la declaración de la fórmula, se emplean
otros sı́mbolos cuyo papel se recoge en la Tabla 18.1
Tabla 18.1: Sı́mbolos empleados en las fórmulas.
Sı́mbolo Acción Ejemplo

+ incluye una variable y˜x+a
- excluye una variable y˜x-a
: incluye una interacción entre dos va- y ˜ x:a
riables
* incluye dos variables y su interacción y ˜ x*a = x + a + x:a
/ incluye una variable
| incluye una tercera variable factor y˜x|a
I() incluye como variable el resultado de y ˜ x + I(xˆ2)
una operación aritmética
. incluye todas las variables indepen- y˜.
dientes
201
202 CAPÍTULO 18. FÓRMULAS EN R
18.2. Uso
Las fórmulas se emplean fundamentalmente en el modelado de regresión
(lm(), glm(), etc.), aunque también se emplean en gráficos lattice y en alguna
función (xtabs(), plot(), boxplot(), etc.)
18.2.1. Fórmulas en gráficos

Muchas funciones gráficas admiten fórmulas. Veamos algunos ejemplos:
Ejemplo 18.1. Declare una fórmula para ((plot())) y compruebe su clase.
> form1 <- y ˜ x # se crea una fórmula y se asigna

> class(form1) # se comprueba la clase del objeto
[1] "formula"
> form1 # se imprime el objeto
y ˜ x
Ejemplo 18.2. Dibuje la nube de puntos con los siguientes datos: x = 1:30 e y
= rpois(30, 4) + x.
> set.seed(2016)
> x <- 1:30
> y <- rpois(30, 4) + x
> plot(form1)
Figura 18.1: Nube de puntos con las variables x e y.
●
35
●
● ●
30
●
●
●
●
●
25
●
●
●
●
20
● ●
y
●
●
15
● ●●
●
● ●
10
● ● ●
●
●
5
●
●
0 5 10 15 20 25 30
Ejemplo 18.3. Emplee de tres formas diferentes la función plot() para ob-
tener el mismo gráfico.
> opar <- par(mfrow = c(1, 3))

> plot(x, y, main = ’dos variables\n((x, y))’)

18.2. USO 203
> plot(y ˜ x, main = ’fórmula\n((y ˜ x))’)

> plot(form1, main = ’objeto fórmula\n((form1))’)
www.editorialuc.es
> par(opar); rm(opar)
Figura 18.2: Nube de puntos con las variables x e y.

dos variables fórmula objeto fórmula
«x, y» «y ~ x» «form1»
● ● ●
35
35
35
● ● ●
● ● ● ● ● ●
30
30
30
● ● ●
● ● ●
● ● ●
● ● ●
● ● ●
25
25
25
● ● ●
● ● ●
● ● ●
● ● ●
20
20
20
● ● ● ● ● ●
y
y
● ● ●
● ● ●
15
15
15
● ●● ● ●● ● ●●
● ● ●
● ● ● ● ● ●
10
10
10
● ● ● ● ● ● ● ● ●
● ● ●
● ● ●
5
5
● ● ●
● ● ●
0 5 10 15 20 25 30 0 5 10 15 20 25 30 0 5 10 15 20 25 30
x x x
Evidentemente, los tres gráficos son iguales.
Ejemplo 18.4. Represente la fuerza máxima de los adolescentes en función

de la edad y sexo utilizando una fórmula con la función xyplot().
> xyplot(fmax ˜ edad | sexo, data = DATA)
Figura 18.3: Fuerza máxima en los adolescentes según edad y sexo.
13 14 15 16 17 18
Femenino Masculino
●
●
50 ●
● ● ●●
● ●● ● ●●
● ● ● ●
● ● ●
●● ● ●
● ● ● ●●
● ● ●● ● ●●● ● ● ● ● ●
40 ● ● ●
●
●●● ●● ●
fmax
●● ● ● ● ●
● ●
●●● ●● ●
●●●● ● ●●● ●● ●
● ●● ● ● ● ●●● ●● ● ●
●
●●
●
●● ●● ●
●● ● ●●●● ●● ●● ● ●●
●●● ● ● ● ●● ●
30 ● ●● ●
●● ● ● ● ● ● ● ●●● ●●
● ● ● ● ●● ●● ● ●●●●●● ●●● ● ●● ●●●●●● ●●● ●
●●
●● ●
● ● ● ● ●● ●● ● ●
●●●●● ●●● ●●● ●●● ●●●
● ● ●● ●●●● ●●●●
●●● ●● ●● ●●● ● ● ●●
● ● ●
● ● ●● ● ● ●●
● ●●● ● ●● ●●
● ●
●●●
● ●●
● ●● ●●●●● ● ●●●● ● ● ●
●●● ●● ●●● ●● ● ●● ●
● ● ● ●●●●●
● ●
● ●●●
● ●●
●
● ●●●●●
● ●●● ●●
●● ● ●●●
●●
●
●
●●
● ●
●● ● ●● ● ● ● ●
●
● ●
● ● ●●●● ● ● ● ●● ●● ●
●●
●
●
●
●● ●●● ●
● ●● ●
● ●● ●
●
20 ●●●●
●
●●
●
●
●● ●●
●● ● ●● ●
● ● ●● ●●●
●●● ●●● ● ● ●
●●●● ●● ●
●
●●●
●
13 14 15 16 17 18
edad
Ejemplo 18.5. Represente mediante un histograma de puntos la fuerza máxi-

ma de los adolescentes en función de su edad y sexo utilizando la función
masaic::dotPlot() y una fórmula.
> require(mosaic)
> x <- floor(DATA$edad)
> DATA$x <- factor(x, levels = 12:17)
> dotPlot(˜ fmax | x + sexo,
+ data = DATA, nint = 20,
+ layout = c(6,2), aspect = 1,
+ xlab = "Fuerza (kgf)", cex = .7)

Figura 18.4: Fuerza máxima en los adolescentes según edad y sexo.
10 20 30 40 50 60 10 20 30 40 50 60 10 20 30 40 50 60
Masculino Masculino Masculino Masculino Masculino Masculino

12 13 14 15 16 17
● 8
● ●
●●●● ● ● 6
● ●●●●● ● ●● ●●● ●
●●●
● ●●●●● ● ● ●● ●● ● ●●● ●●●●● ● ● 4
●●●
●●●
● ● ●●●●●● ● ● ●●●●●● ● ●●●●● ● ● ●●●●● ●●● ● ● ●●
●●●
●●●● ●
● ● ●●●●●●● ● ● ●●●●●●● ●●● ●● ●●●●● ●● ● ●● ●●●●●●●●● ● ●● ● ●● ●● 2
●
●●●
●●
●●
●●
●●
●●● ● ●● ●●●●●●●●●●●●●●● ●●●●●●●●●●●●●●●●● ●●●●●●●●●●●●●●●●● ●●●●●●●●●●●●●● ●●●● ● ●●●●●●●●●●● ●
0
Count
Femenino Femenino Femenino Femenino Femenino Femenino

12 13 14 15 16 17
● ●
8 ● ●
● ●
6 ● ● ●●
● ● ●●● ●●
4 ●● ● ●●●
● ●● ●●● ●●
●● ●
●● ●●●●
●●●● ● ●● ● ●
●●●●● ●● ●
●●
● ●● ●
2 ●●●●
●●●● ● ●●
●●●
● ●
●●●
●● ● ●●●●● ● ● ●
●●●
●●
●●
● ●●●●●
●●
●●● ●●●●●●
●●
●●
●●●
●●
●●●
●●
●●● ●●
●●
●●
●●
●●●
●●●● ● ●●●●●●●●●●●● ● ●
●●
● ●
●●●
●●
●●● ●
● ●
●●●
●●
●●●
●●
●●
●●●
●● ●●●
● ●●●●
●● ●
●
0
10 20 30 40 50 60 10 20 30 40 50 60 10 20 30 40 50 60
Fuerza (kgf)
18.2.2. Fórmulas en modelos de regresión

El el modelado de regresión lineal, regresión logı́stica, etc. se emplean fórmu-
las. Veamos algunos ejemplos:
Ejemplo 18.6. Con la BdD de Fuerza modele la fuerza máxima de los adoles-
centes en función de su edad, IMC, sexo, peso, talla y mano dominante (sin
interacciones).
> load(’bd_Fuerza.RData’)
> names(DATA)
[1] "id" "ies" "edad" "curso" "sexo" "md" "sus"
[8] "peso" "talla" "fmd" "fmi" "fmax" "imc"
> lm1 <- lm(fmax ˜ edad + imc + sexo + peso + talla + md,
+ data = DATA)
> summary(lm1)
Call:
lm(formula = fmax ˜ edad + imc + sexo + peso + talla + md, data = DATA)
Residuals:
Min 1Q Median 3Q Max
-14.8454 -3.0234 -0.2797 2.9148 19.0408
Coefficients:
Estimate Std. Error t value Pr(>|t|)
(Intercept) 6.68370 20.56654 0.325 0.74535
edad 0.80824 0.17942 4.505 8.49e-06 ***
imc -0.89490 0.47353 -1.890 0.05943 .
sexoMasculino 5.38189 0.52318 10.287 < 2e-16 ***
peso 0.48687 0.17372 2.803 0.00529 **
talla -0.01917 0.12876 -0.149 0.88172
mdizquierda 1.19024 0.74923 1.589 0.11285
---
Signif. codes: 0 ‘***’ 0.001 ‘**’ 0.01 ‘*’ 0.05 ‘.’ 0.1 ‘ ’ 1
Residual standard error: 4.952 on 447 degrees of freedom

Multiple R-squared: 0.5952,Adjusted R-squared: 0.5898

F-statistic: 109.5 on 6 and 447 DF, p-value: < 2.2e-16
www.editorialuc.es
La función update() es muy útil en el modelado ya que ahorra teclear de
nuevo. Aquı́ el ((.)) significa que se incluyen todas las variables del modelo y
con ((–)) se excluyen las que se quieran.
Ejemplo 18.7. Elimine las variables peso y md del modelo y ajuste de nuevo.
> lm2 <- update(lm1, . ˜ . - peso - md)

> summary(lm2)
Call:
lm(formula = fmax ˜ edad + imc + sexo + talla, data = DATA)
Residuals:
-15.2132 -3.0861 -0.5013 3.1054 18.6112
Coefficients:
(Intercept) -50.01263 4.09628 -12.209 < 2e-16 ***
edad 0.75041 0.17938 4.183 3.46e-05 ***
imc 0.43020 0.06743 6.380 4.41e-10 ***
sexoMasculino 5.62077 0.52319 10.743 < 2e-16 ***
talla 0.33095 0.03058 10.823 < 2e-16 ***
---
Signif. codes: 0 ‘***’ 0.001 ‘**’ 0.01 ‘*’ 0.05 ‘.’ 0.1 ‘ ’ 1

18.2.3. Fórmulas en determinadas funciones

Algunas funciones utilizan fórmulas. Por ejemplo, vimos la función xtabs()
en el capı́tulo dedicado a las tablas en un ejemplo que repetimos aquı́
Ejemplo 18.8. Cree una tabla de la distribución del consumo de alcohol en

el estudio de casos y controles recogido en la BdD esoph presente en los
datasets de R.
> xtabs(cbind(ncases, ncontrols) ˜ alcgp, data = esoph)

0-39g/day 29 415
40-79 75 355
80-119 51 138
120+ 45 67

tablas:

Función Acción
boxplot() Gráfico boxplot
class() Asigna una clase a un objeto
dotPlot() Histograma de puntos (paquete ((mosaic)))
floor() Redondea hacia abajo
glm() Modelo generalizado
lm() Regresión lineal
load() Lee un objeto guardado en un fichero
names() Asigna nombres a un objeto
par() Asigna un parámetro gráfico
plot() Función genérica de dibujo
require() Lee un paquete
rpois() Vector de elementos que siguen una distribución de Poisson
set.seed() Fija semilla aleatoria
summary() Función genérica de sı́ntesis de un objeto
update() Actualiza un modelo
xtabs() Genera tablas
xyplot() Gráfico condicional
Función Acción
mosaic Funciones generales de R con mosaic [185]
PROBLEMAS
Problema 1. Utilizando una fórmula cree una tabla de la distribución de alumnos
por centro escolar y sexo en la BdD del estudio de la fuerza en adolescentes de 12 a 17
años de edad.
Problema 2. En la fuerza máxima de los adolescentes, ¿interacciona la edad con el
sexo significativamente? Compruébelo creando el modelo adecuado con una fórmula.

www.editorialuc.es
Capı́tulo 19
Entornos en R
Un entorno (environment) es una colección de nombres de variables que

apuntan a su contenido que está en algún lugar de la memoria del ordena-
dor [148].
Como el contenido de los objetos no está en el entorno, varios nombres
pueden apuntar a un mismo objeto (contenido) e, incluso, el contenido al que
apuntan dos nombre puede ser igual, pero almacenado en diferentes lugares de
la memoria (Fig. 19.1). Todo contenido en la memoria RAM que no esté apun-
tado por algún nombre en un entorno será borrado por R (garbage collector).
Figura 19.1: Estructura de un entorno que contiene tres nombres. Éstos apuntan a
algún lugar de la memoria RAM donde está almacenado su contenido. Con el punto
y flecha hacia la izquierda se quiere indicar que el entrono ((e)) cuelga de su entorno
padre.
Entorno «e»
c 1, 2, ..., 10
Entorno padre
1, 2, ..., 5
b
A, B, ..., J
a TRUE
●
El concepto de entorno no es fundamental en un primer contacto con R.
207
208 CAPÍTULO 19. ENTORNOS EN R
19.1. Tipos
Un marco (frame) asocia nombres con valores [151, 186]. Un entorno es un
marco más una referencia (llamada enclosure) a otro entorno 1 .
19.1.1. El entorno global

El entorno global (global environment) es el entorno en el que normalmen-
te se trabaja, por eso también se llama entorno de trabajo (xxx). La función
globalenv() presenta el entorno global donde se realiza el trabajo interacti-
vo ceno R.
> globalenv()
<environment: R_GlobalEnv>
19.1.2. El entorno base

El entorno base (base environment) es el entorno del paquete base. Su padre
es el entorno vacı́o. La función baseenv() presenta el entorno base
> baseenv()
<environment: base>
19.1.3. El entorno vacı́o

El entorno vacı́o (empty environment) es el ancestro de todos los entornos,
por tanto no tiene entorno padre. La función emptyenv() presenta el entorno
vacı́o
> emptyenv()
<environment: R_EmptyEnv>
19.1.4. El entorno de trabajo

El entorno actual (current environment) es el entorno de trabajo. La función
environment() presenta el entorno actual
> environment()
19.2. Papel del entorno

El papel del entorno es permitir el ámbito léxico: si un nombre no se encuen-
tra en un entorno, R buscará en el entorno padre, y ası́ sucesivamente hasta el
entorno vacı́o.
Una función importante es search() que permite ver el entorno de trabajo
y todos sus ancestros (Figura 19.2).
1 Según Venables y Ripley: ((An environment is a frame plus an enclosure, a reference an other envi-
ronment, so environments are organized as a tree)). [151]

19.2. PAPEL DEL ENTORNO 209
Figura 19.2: Entornos en R puestos de manifiesto con search().
www.editorialuc.es
search()
● emptyenv()
● baseenv() Base
● Autoloads
search() ● methods
datasets
utils
Packages
● grDevices
graphics
● stats
globalenv()
Entorno de trabajo
● environment()
Cuando se ejecuta esta función aparecen los que se presentan en el ejemplo

siguiente (y alguno más si ha cargado otros paquetes con library() o con
require().
Ejemplo 19.1. Ejecute la función search().

> search()
[1] ".GlobalEnv" "tools:rstudio" "package:stats"
[4] "package:graphics" "package:grDevices" "package:utils"
[7] "package:datasets" "package:methods" "Autoloads"
[10] "package:base"
Ejemplo 19.2. Ejecute la función searchpaths().

> searchpaths()
[1] ".GlobalEnv"
[2] "tools:rstudio"
[3] "/Library/Frameworks/R.framework/Versions/3.3/Resources/library/stats"
[4] "/Library/Frameworks/R.framework/Versions/3.3/Resources/library/graphics"
[5] "/Library/Frameworks/R.framework/Versions/3.3/Resources/library/grDevices"
[6] "/Library/Frameworks/R.framework/Versions/3.3/Resources/library/utils"
[7] "/Library/Frameworks/R.framework/Versions/3.3/Resources/library/datasets"
[8] "/Library/Frameworks/R.framework/Versions/3.3/Resources/library/methods"
[9] "Autoloads"
[10] "/Library/Frameworks/R.framework/Resources/library/base"
Las BdD (dataframe) ancladas (attached) en el entorno de trabajo con la fun-

ción attach() también aparecen. Cuando ejecuta la función detach() des-
aparecen en el listado proporcionado por search().

Ejemplo 19.3. Ancle la BdD ((Fuerza)) y compruebe que aparece cuando eje-
cuta la función search().
> load(’bd_Fuerza.RData’)
> attach(DATA)
> search()
[1] ".GlobalEnv" "DATA" "tools:rstudio"
[4] "package:stats" "package:graphics" "package:grDevices"
[7] "package:utils" "package:datasets" "package:methods"
[10] "Autoloads" "package:base"
19.3. Otras funciones para manejar el entorno

19.3.1. Crear
Para crear un nuevo entorno se utiliza la función new.env().
Ejemplo 19.4. Cree un nuevo entorno que contenga tres objetos: a = 1:10, b
= list(num = 1:5, char = LETTERS[1:10]) y c = TRUE).
> e <- new.env()

> e$a = 1:10
> e$b = list(num = 1:5, char = LETTERS[1:10])
> e$c = TRUE
19.3.2. Explorar
Para explorar un entorno se utilizan las funciones ls() y ls.str().
Ejemplo 19.5. ¿Qué contiene el entorno ((e))?
> ls(e)
[1] "a" "b" "c"
El entorno ((e)) contiene tres objetos: a, b y c.

Mejor es utilizar la función ls.str() para ver el contenido de estos tres
objetos:
Ejemplo 19.6. ¿Qué contiene el entorno ((e)) (más detalladamente)?
> ls.str(e)
a : int [1:10] 1 2 3 4 5 6 7 8 9 10
b : List of 2
$ num : int [1:5] 1 2 3 4 5
$ char: chr [1:10] "A" "B" "C" "D" ...
c : logi TRUE
Ejemplo 19.7. ¿Qué contiene el paquete ((graphics))?
> ls(package:graphics)
[1] "abline" "arrows" "assocplot"

[4] "axis" "Axis" "axis.Date"

[7] "axis.POSIXct" "axTicks" "barplot"
www.editorialuc.es
[10] "barplot.default" "box" "boxplot"
[13] "boxplot.default" "boxplot.matrix" "bxp"
[16] "cdplot" "clip" "close.screen"
[19] "co.intervals" "contour" "contour.default"
--------------- lı́neas omitidas ----------------
[55] "plot" "plot.default" "plot.design"
[58] "plot.function" "plot.new" "plot.window"
[61] "plot.xy" "points" "points.default"
[64] "polygon" "polypath" "rasterImage"
[67] "rect" "rug" "screen"
[70] "segments" "smoothScatter" "spineplot"
[73] "split.screen" "stars" "stem"
[76] "strheight" "stripchart" "strwidth"
[79] "sunflowerplot" "symbols" "text"
[82] "text.default" "title" "xinch"
[85] "xspline" "xyinch" "yinch"
19.3.3. Borrar
Para ubicar un entorno se utilizan las funciones rm().
Ejemplo 19.8. Elimine el entorno ((e))?
> rm(e)
19.3.4. Ubicar
Para ubicar un entorno se utilizan las funciones parent.env().
Ejemplo 19.9. ¿Quién es el entorno padre del entorno ((e))?
> e <- new.env()

> e$a = 1:10
> e$b = list(num = 1:5, char = LETTERS[1:10])
> e$c = TRUE
> parent.env(e)
Ejemplo 19.10. ¿Quién es el entorno padre del entorno base?
> parent.env(baseenv())
<environment: R_EmptyEnv>

tablas:

Función Acción
attach() Fija un dataframe y hace accesible sus variables
detach() Desliga el dataframe
emptyenv() Presenta el entorno vacı́o
environment() Presenta el entorno actual
globalenv() Presenta el entorno global
ls() Lista los objetos de un entorno
ls.str() Lista los objetos de un entorno con su contenido
new.env() Crea un nuevo entorno
parent.env() Presenta el entorno padre del entorno actual
rm() Borra los objetos de un entorno
search() Presenta el entorno global y todos sus ancestros
searchpaths() Idem, pero presentando el path donde está su código
PROBLEMAS
Problema 1. ¿Qué obtiene cuando ejecuta la función searchpaths()?
Problema 2. Compruebe que desaparece del resultado proporcionado por la función
search() cuando ejecuta la función detach() pasando como argumento DATA.

www.editorialuc.es
Parte III
GRÁFICOS EN R

www.editorialuc.es
Capı́tulo 20
Gráficos tradicionales
Una de las caracterı́sticas en las que destaca R es en sus excelentes ca-

pacidades gráficas [187, 188]. En la distribución básica existen dos paquetes:
graphics [103] y lattice [189]. Vamos a ver las caracterı́sticas más impor-
tantes de ambos sistemas gráficos, empezando en este capı́tulo con los gráficos
tradicionales.
Los gráficos ((tradicionales)) se desarrollaron inicialmente en los laborato-
rios Bell con el lenguaje S [87, 90].
Para explorar adecuadamente las posibilidades gráficas de R vamos a tra-
bajar con una BdD cuyas principales caracterı́sticas son:
pima. Esta base de datos está tomada del paquete MASS que consta de 632
registros, de los que 532 están completos y 100 tienen algunos datos au-
sentes. En una población de mujeres indias Pima de 21 años y más de
Phoenix, Arizona (EE. UU.) que llevaban más de cinco años viviendo en
esa comunidad, se investigó la presencia de diabetes según criterios de
la OMS. Los datos están grabados en el fichero bd Pima.csv y con los
nombres de las variables traducidos al español: id número de identifica-
ción, emb número de embarazos, glu p glucemia postprandial (mg/dL),
tad TAD (mm Hg), ptri grosor del pliegue tricipital (mm), imc IMC
(kg/m2 ), fp dia función de pedigree de la diabetes, edad edad (años) y
dial presencia de diabetes según criterios de la OMS.
> pima <- read.csv2(file = ’bd_Pima.csv’)

> str(pima)
$ id : int 1 2 3 4 5 6 7 8 9 10 ...
$ emb : int 5 7 5 0 0 5 3 1 3 2 ...
$ glu_p : int 86 195 77 165 107 97 83 193 142 128 ...
$ tad : int 68 70 82 76 60 76 58 50 80 78 ...
$ ptri : int 28 33 41 43 25 27 31 16 15 37 ...
$ imc : num 30.2 25.1 35.8 47.9 26.4 35.6 34.3 25.9 32.4 43.3 ...
$ fp_dia: num 0.364 0.163 0.156 0.259 0.133 ...
$ edad : int 24 55 35 26 23 52 25 24 63 31 ...
$ diab : Factor w/ 2 levels "N","S": 1 2 1 1 1 2 1 1 1 2 ...
215
216 CAPÍTULO 20. GRÁFICOS TRADICIONALES
20.1. Las tres regiones de un gráfico

En un gráfico ((tradicional)) en R se han de distinguir tres regiones: (1) El
margen externo (outer margin) que rodea al margen interno (outer margin) for-
mado este último por dos zonas: (2) la región del dibujo (plot region) y (3)nun
margen de la figura (figure margin). En la Figura 20.1 pueden apreciarse estas
regiones.
Región de dibujo. Esta región (plot region) es donde se representan los da-
tos. Según el tipo de gráficos se representan lı́neas, puntos, etc.
Margen de la figura. Esta región (figure margin) es donde se anotan las eti-
quetas de las variables.
Margen del gráfico. Esta región (outer margin) Se pueden utilizar hasta 4
lı́neas para otro tipo de anotaciones.
Figura 20.1: Rótulo.
El control de muchas de las caracterı́sticas de estas regiones se hace vı́a

par(). Se pueden controlar estas caracterı́sticas mediante:
20.1.1. Fijaciones de nivel alto

Son un conjunto de declaraciones que mediante par() o como argumentos
de algunas funciones permiten fijar una serie de parámetros. Se presentan en
la Tabla 20.1.

20.1. LAS TRES REGIONES DE UN GRÁFICO 217
Tabla 20.1: Fijaciones de alto nivel (hight-level traditional graphics

state settings) utilizadas en los gráficos tradicionales
www.editorialuc.es
Función Acción
adj Justificación del texto
ann ¿Poner etiquetas y tı́tulos?
bg Color background
bty Tipo de caja dibujada por box()
cex Tamaño del texto
cex.axis Tamaño de las escalas de los ejes
cex.lab Tamaño de las etiquetas de los ejes (variables)
cex.main Tamaño del tı́tulo
cex.sub Tamaño del subtı́tulo
col Color del gráfico
col.axis Color de los ejes
col.lab Color de las etiquetas
col.main Color del tı́tulo
col.sub Color del subtı́tulo
fg Color del marco de los ejes foreground
font Fuente para el texto
font.axis Fuente para los ejes
font.lab Fuente para las etiquetas
font.main Fuente para el tı́tulo
font.sub Fuente para el subtı́tulo
gamma Corrección gamma de los colores
lab Número de marcas en los ejes
las Orientación del texto en los márgenes
lty Tipo de lı́nea
lwd Anchura de la lı́nea
mgp Colocación de las marcas en los ejes y sus etiquetas
pch Tipo de sı́mbolo para los puntos
set Rotación del texto en la región del gráfico
tck Longitud de los ticks respecto del gráfico
tcl Longitud de los ticks respecto del texto
tmag Tamaño del tı́tulo respecto de las etiquetas
type Tipo de plot (puntos, lı́neas o ambos o ninguno)
xaxp Número de ticks en el eje de abscisas
xaxs Cálculo del rango de la escala en el eje de abscisas
xaxt Estilo del eje de abscisas (standard, none)
xpd Region de recorte
yaxp Número de ticks en el eje de ordenadas
yaxs Cálculo del rango de la escala en el eje de ordenadas
yaxt Estilo del eje de ordenadas (standard, none)
20.1.2. Fijaciones de nivel bajo

Son un conjunto de declaraciones que mediante par() permiten fijar una
serie de parámetros. Se presentan en la Tabla 20.2.

Tabla 20.2: Fijaciones de bajo nivel (low-level traditional graphics

state settings) utilizadas en los gráficos tradicionales
Función Acción
ask Pregunta al usuario si desea un nuevo gráfico
family Familia de las fuentes para el texto
fig Localización normalizada de la zona de figura
fin Tamaño de la región figura (pulgadas)
lend Estilo para el final de lı́nea
lheight Espaciado de lı́neas
ljoin Estilo de unión de lı́neas
lmitre Lı́mite de la lı́nea inglete de unión
mai Tamaño del margen de la figura (pulgadas)
mar Tamaño del margen de la figura (en lı́neas de texto)
mex Espaciado de la lı́neas en los márgenes
mfcol Número de figuras
mfg Figura próxima
mfrow Número de figuras
new Nueva figura
oma Tamaño de los márgenes (lı́neas de texto)
omd Localización de la región interior
omi Tamaño de los márgenes (pulgadas)
pin Tamaño de la región de dibujo (pulgadas)
plt Localización de la región de dibujo (normalizada)
ps Tamaño del texto (puntos)
pty Proporción de la región de dibujo
usr Rango de las escalas de los ejes
xlog Escala logarı́tmica para las abscisas
ylog Escala logarı́tmica para las ordenadas
20.2. Caracterı́sticas de un gráfico

En un gráfico, además de la idea que se quiere representar, hay que tener
en consideración unas cuantas caracterı́sticas, que se van a ir analizando a con-
tinuación.
20.2.1. Color
Con el parámetro col = ? se pueden pasar colores a un gráfico. Los co-
lores básicos (Figura 20.2) son: 1 = negro, 2 = rojo, 3 = verde, 4 = azul, 5 = cyan,
6 = magenta y 7 = amarillo. Se pueden especificar como número (por ejem-
plo, para el rojo: col = 2) o como texto (por ejemplo, para el verde: col =
’green’). Además de estos 7 colores primarios, R ofrece 657 colores, cuyos
nombres se pueden ver con la función colors(). Por ejemplo, uno de ellos es
col = ’lightblue’.
También se pueden especificar los flores mediante la función rgb(), con
tres componentes cuyo valor va de 0 a 1. Por ejemplo, si se deseara dibujar algo
en color rojo se pondrı́a col = rgb(1, 0, 0). Con la función col2rgb()
se puede conocer el valor de los tres números para un color determinado.

20.2. CARACTERÍSTICAS DE UN GRÁFICO 219
Otra forma de especificar los colores es con ’#000000’, en el que cada dos
cifras (que van de 00 a FF, en hexadecimal) permiten especificar la cantidad de
www.editorialuc.es
rojo, verde y azul, por lo que hay 256 ∗ 256 ∗ 256 = 16777216 colores. Por ejem-
plo, el rojo es: col = "#FF0000". Se pueden añadir dos cifras que indican el
grado de transparencia (desde 00 a 99).
Figura 20.2: Caracterı́sticas de un gráfico: colores, puntos, lı́neas...
7 yellow 9= 19 = ●
8= 18 =
6 magenta 6
7= 17 =
5 cyan 6= 16 = ● 5
5= 15 = 25 =
4 blue 4
4= 14 = 24 =
3 green 3= 13 = ● 23 = 3
2= 12 = 22 =
2 red 2
1= ● 11 = 21 = ●
1 black 0= 10 = ● 20 = ● 1
R dispone de otras funciones relacionadas con el color que permiten una

transición: grey() o gray() permite crear una transición del blanco → negro;
rainbow() permite crear una transición rojo → violeta, heat.colors() con
transición blanco → naranja → rojo; terrain.colors() transición blanco →
marrón → verde; topo.colors() transición blanco → marrón → verde →
azul; cm.colors() transición azul → blanco → magenta.
20.2.2. Lı́neas
El tipo de lı́nea, que se elige con ltype = x (siendo x un número entre 1
y 6), permite elegir entre lı́nea continua, de puntos, de rayas, etc (Figura 20.2).
El grosor del trazo se controla con el parámetro lid = y, siendo y igual a 1, 2,
etc.
20.2.3. Sı́mbolos
Los sı́mbolos gráficos pueden ser letras, puntos, etc. además de los 27 reco-
gidos en la Figura 20.2. Se controlan con el parámetro pch = z, siendo z un
número entre 0 y 25, además de letras, etc.

20.2.4. Figuras
Por defecto R dibuja puntos, pero es posible dibujar lı́neas verticales, lı́neas,
lı́neas y puntos o lı́neas quebradas.
Ejemplo 20.1. Sea x = 1:10 e y <- c(7.5, 4, 2.6, 0.9, 0.4,

0.8, 2, 3.8, 5.5, 9). Represente con la función plot() los seis tipos
de figuras.
Figura 20.3: Los seis tipos de figuras con plot() según el parámetro type.
type = "p" type = "l" type = "b"
● ●
8
8
● ●
6
6
● ●
y
y
● ●
4
4
● ●
● ●
● ●
2
2
● ● ● ●
● ●
2 4 6 8 10 2 4 6 8 10 2 4 6 8 10
x x x
type = "o" type = "h" type = "s"
●
8
●
6
●
y
●
4
●
2
● ●
●
2 4 6 8 10 2 4 6 8 10 2 4 6 8 10
x x x
> x <- 1:10

> y <- c(7.5, 4, 2.6, 0.9, 0.4, 0.8, 2, 3.8, 5.5, 9)
> plot(x, y, ty = ’p’, main = ’type = "p"’)
> plot(x, y, ty = ’l’, main = ’type = "l"’)
> plot(x, y, ty = ’b’, main = ’type = "b"’)
> plot(x, y, ty = ’o’, main = ’type = "o"’)
> plot(x, y, ty = ’h’, main = ’type = "h"’)
> plot(x, y, ty = ’s’, main = ’type = "s"’)
20.2.5. Textos
R permite incluir texto en los gráficos: la función mtext() para los márge-
nes y text() para la región gráfica.
Con el parámetro par : adj = 0 ajustado por la izquierda, adj = 0.5
centrado y adj = 1 ajustado por la derecha.
En la región gráfica el ajuste puede admitir dos valores: adj = c(x, y),
en el que el valor x es para el ajuste horizontal, como hemos visto, y el valor y
es para el ajuste vertical.

20.3. FUNCIONES GRÁFICAS 221
Varias lı́neas de texto se consiguen insertando \n en la cadena en el lugar

donde se desee que comience un nuevo renglón.
www.editorialuc.es
Con el parámetro font = x se controlan las fuentes: 1 para texto normal, 2
para texto en negrita, 3 para texto en cursiva y 4 para texto en cursiva y negrita.
20.3. Funciones gráficas

Podemos dividir las funciones gráficas en cuatro categorı́as [144]: (1) fun-
ciones de alto nivel, (2) de bajo nivel, (3) funciones interactivas, y (4) gráficos
condicionales.
20.4. Funciones gráficas de alto nivel

Son las que dibujan gráficos completos en la ventana gráfica activa. En la
Tabla 20.3 se presentan los principales gráficos, aunque hay más ya que mu-
chos paquetes incorporan nuevos gráficos que ponen de manifiesto relaciones
entre los datos con los que se trabaja, por ejemplo la función tableplot()
del paquete tabplot [190, 191].
Tabla 20.3: Funciones gráficas más utilizadas en R..
Una variable Dos variables Más de dos variables

Cualitativa: dotchart() pairs()
barplot() plot() interactionplot()
pie() sunflowerplot() matplot()
Numérica: mosaicplot() cdplot()
hist() assocplot() contour()
density() fourfoldplot() persp()
stripchart() heatmap()
boxplot()
qqnorm()
qqline()
20.4.1. Funciones para una variable

Dos son las principales funciones para representar una variable cualitativa:
barplot() y pie().
barplot()
Crea un gráfico de barras. Útil para variables cualitativas o numéricas dis-
cretas. Un gráfico de barras es como un histograma pero con una variable cua-
litativa en el eje de abscisas.
#---------------------------------------------------------------
barplot(height, width = 1, space = NULL,

names.arg = NULL, legend.text = NULL, beside = FALSE,

horiz = FALSE, density = NULL, angle = 45,
col = NULL, border = par("fg"),
main = NULL, sub = NULL, xlab = NULL, ylab = NULL,
xlim = NULL, ylim = NULL, xpd = TRUE, log = "",
axes = TRUE, axisnames = TRUE,
cex.axis = par("cex.axis"), cex.names = par("cex.axis"),
inside = TRUE, plot = TRUE, axis.lty = 0, offset = 0,
add = FALSE, args.legend = NULL, ...)
#---------------------------------------------------------------
Ejemplo 20.2. Cree un gráfico de barras con el número de embarazos.

> with(pima, barplot(table(emb)))
120
100
80
60
40
20
0
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 17
Figura 20.4: Número de embarazos en las indias Pima.
pie()
Crea una gráfico de tartas. La amplitud del sector es proporcional a la fre-
cuencia de efectivos en esa categorı́a. Es poco apreciado por los estadı́sticos
debido a la incapacidad del ojo humano de diferenciar bien entre el número de
grados de dos sectores, como se puede apreciar en la Figura 20.5.
#---------------------------------------------------------------
pie(x, labels = names(x), edges = 200, radius = 0.8,
clockwise = FALSE, init.angle = if(clockwise) 90 else 0,
density = NULL, angle = 45, col = NULL, border = NULL,
lty = NULL, main = NULL, ...)
#---------------------------------------------------------------
Ejemplo 20.3. Cree un gráfico de tartas con la tabla del número de embara-
zos de las indias Pima.
> with(pima, pie(table(emb)))
Se aprecia que nos es difı́cil decidir sobre el tamaño del sector 0 y 2, o entre
el 6 y el 7, mientras que en la Figura 20.4 no hay problema.
Hay varias funciones para representar una única variable numérica: hist(),
density(), stripchart(), boxplot(), qqnorm(), qqline().

20.4. FUNCIONES GRÁFICAS DE ALTO NIVEL 223
www.editorialuc.es
Figura 20.5: Gráfico con la función pie().
hist()
Crea un histograma. Se utiliza con variables numéricas continuas. Puede
ofrecer diferentes resultados según la anchura de los intervalos, de ahı́ que no
sea el más apreciado por los estadı́sticos cuando se quiere graficar una variable
numérica.
#---------------------------------------------------------------
hist(x, breaks = "Sturges",
freq = NULL, probability = !freq,
include.lowest = TRUE, right = TRUE,
density = NULL, angle = 45, col = NULL, border = NULL,
main = paste("Histogram of" , xname),
xlim = range(breaks), ylim = NULL,
xlab = xname, ylab,
axes = TRUE, plot = TRUE, labels = FALSE,
nclass = NULL, ...)
#---------------------------------------------------------------
Ejemplo 20.4. Histograma de la tensión arterial diastólica de las indias Pima.

> with(pima,
+ hist(tad, col = 5, main = ’’))
> with(pima, {
+ hist(tad, prob = TRUE, ylim = c(0, 0.035),
+ main = ’’, col = 5)
+ lines(density(tad, na.rm = TRUE), lwd = 2)}
+ )
density()
A ñade una lı́nea de densidad a un histograma (de probabilidad).

0.000 0.010 0.020 0.030

150
Frequency
Density
100
50
0
20 40 60 80 100 120 20 40 60 80 100 120
tad tad
Figura 20.6: En al lado izquierdo el histograma y en el lado derecho un histograma de

probabilidad con la curva de densidad.
#---------------------------------------------------------------
density(x, bw = "nrd0", adjust = 1,
kernel = c("gaussian", "epanechnikov", "rectangular",
"triangular", "biweight",
"cosine", "optcosine"),
weights = NULL, window = kernel, width,
give.Rkern = FALSE,
n = 512, from, to, cut = 3, na.rm = FALSE, ...)
#---------------------------------------------------------------
Ejemplo 20.5. Histograma de probabilidad con lı́nea de densidad de la ten-

sión arterial diastólica.
En la Figura 20.6, lado derecho, se presenta el histograma con la curva de
densidad.
stripchart()
Este tipo de gráficos, también llamados dot plot, son una alternativa a los
gráficos de tallos y hojas [172]. En una lı́nea se van colocando todos los puntos
y si alguno coincide con otro se coloca encima.
#---------------------------------------------------------------
stripchart(x, method = "overplot", jitter = 0.1, offset = 1/3,
vertical = FALSE, group.names, add = FALSE,
at = NULL, xlim = NULL, ylim = NULL,
ylab=NULL, xlab=NULL, dlab="", glab="",
log = "", pch = 0, col = par("fg"), cex = par("cex"),
axes = TRUE, frame.plot = axes, ...)
#---------------------------------------------------------------
Ejemplo 20.6. Cree un gráfico stripchart con las edades de las familias.
> with(familias,
+ stripchart(age, method = ’stack’, offset = 1.5,
+ xlab = ’Age’, pch = 16, col = 3,

+ main = ’Distribución de la Edad’)

+ )
www.editorialuc.es
Distribución de la Edad
● ●
● ● ● ●
● ● ● ● ● ● ● ● ● ● ● ●
● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ●
0 10 20 30 40
Age
Figura 20.7: Edades de la familias representadas con un gráfico stripchar.
Verzani en su paquete UsingR presenta una variante mejorada con la fun-

ción DOTplot().
boxplot()
Este es un gráfico muy utilizado para describir gráficamente una variable
numérica: de un vistazo nos permite hacernos una buena idea de la dispersión
de los datos, de su tendencia central, de la amplitud, de la existencia de valores
extremos, de la simetrı́a, etc. Además, permite comparar varios distribuciones
en un mismo gráfico.
#---------------------------------------------------------------
boxplot(x, ..., range = 1.5, width = NULL, varwidth = FALSE,
notch = FALSE, outline = TRUE, names, plot = TRUE,
border = par("fg"), col = NULL, log = "",
pars = list(boxwex = 0.8, staplewex = 0.5, outwex = 0.5),
horizontal = FALSE, add = FALSE, at = NULL)
#---------------------------------------------------------------
Ejemplo 20.7. Genere en un mismo gráfico dos boxplots, uno con la TAD y
otro con el IMC.
> with(pima, {
+ boxplot(tad, las = 1, col = ’green’,
+ main = ’TAD (mm Hg)’)
+ boxplot(imc, las = 1, col = ’yellow’,
+ main = ’IMC (kg/mˆ2)’) }
+ )

TAD (mm Hg) IMC (kg/m^2)
● ●
●
●
●
100 60 ●
●
●
●
●
80 50
40
60
30
40 ●
●
● 20
Figura 20.8: Gráfico boxplot de la TAD (izquierda) y del IMC (derecha) de las indias
Pima.
20.4.2. Funciones para dos variables

dotchart()
Crea una gráfico de puntos. Los dot chart fueron inventados por William
S. Cleveland [192–195] para mejorar la visualización de los datos frente a una
gráfico de barras. Es como un scatter plot pero con una variable cualitativa en
el eje de ordenadas.
#---------------------------------------------------------------
dotchart(x, labels = NULL, groups = NULL, gdata = NULL,
cex = par("cex"), pch = 21, gpch = 21, bg = par("bg"),
color = par("fg"), gcolor = par("fg"), lcolor = "gray",
xlim = range(x[is.finite(x)]),
main = NULL, xlab = NULL, ylab = NULL, ...)
#---------------------------------------------------------------
Ejemplo 20.8. Cree un gráfico dot chart con el número de embarazos de las
indias Pima. Compárelo con un scatterplot de la frecuencia frente al número.

> x <- table(pima$emb)
> y <- names(x)
> x <- as.numeric(x)
> plot(x, y)
>
> with(pima, dotchart(as.numeric(table(emb))))
> par(opar)
plot()
Es el ((gráfico por excelencia)) en estadı́stica.

● ●
●
15
● ●
● ●
www.editorialuc.es
● ●
● ●
●
●
10
●
●
●
●
y
●
●
●
●
●
● ●
5
● ●
● ●
● ●
● ●
● ●
0
0 20 40 60 80 100 120 0 20 40 60 80 100 120
Figura 20.9: Número de embarazos en las indias Pima (en el lado izquierdo scatterplot
y en el lado derecho dot plot).
#---------------------------------------------------------------
plot(x, y, ...)
#---------------------------------------------------------------
Ejemplo 20.9. Gráfico scatter-plot de las variables glu p y imc.
> with(pima, plot(glu_p ˜ imc))
● ● ● ● ●● ●●
●● ● ●●
● ●● ●● ● ● ●● ●
●● ●
180
●● ● ●● ●● ● ● ● ●●
● ●
●
● ●
● ● ● ● ● ●● ● ●
● ● ● ●● ●● ● ●
● ●●
●●●●● ● ● ●
● ●● ● ● ●
●● ● ● ●● ● ●
●● ●● ●●●●●
● ● ● ●●
● ●● ● ● ● ●●●
●
●●● ● ● ●●● ●● ●
● ●● ● ● ● ●
140
●●● ●●● ●●● ●● ● ●●●● ●● ● ●●●

● ● ●●● ● ● ● ● ●
● ●● ● ●● ● ● ● ●● ● ●● ●● ●
glu_p
● ● ● ●● ● ● ●
● ● ●● ●
●●● ●●
●
● ●
● ●●●● ● ●● ● ●
●● ●●● ●● ● ●
● ● ●●● ●● ●
●●● ●●● ●
●●●●●●●● ● ●● ●
● ● ●● ●●●●●●
●●● ●● ● ● ●
● ● ●● ●● ●
●● ●●● ● ●●●● ●● ● ●●
● ●●●
●
●
● ● ●●●
●● ●●
●● ● ● ●●● ● ● ●●
●● ● ●
●● ● ●●
● ●●●● ●●●●●● ●● ●●● ●
●●●
● ●
●
●●
● ● ●●
●●
●●
●● ● ●
●●
● ●●● ●
● ●
● ● ● ●
●
●●●● ● ● ●● ●● ● ●●
100
● ● ●●
● ●● ●
●●●● ●
● ●●●●●●●●● ● ● ● ●
●●
●● ● ●●●●● ●● ●●
●●
●●● ●●
●●
●●
●●
●●●● ●● ●●
● ●●
●● ●● ●●
● ● ●
●● ●● ●● ● ●● ●● ●●
●
●●●● ●
● ●
●
● ● ●● ●●●
●●●● ●●● ● ●● ● ●
● ●● ●
● ● ●●
●●●
●●● ● ●
●● ● ● ●● ●● ● ●
●●●● ●
80
● ● ●● ●●
●● ● ● ● ● ● ●
● ●● ● ● ●
●● ● ●●● ●●
● ● ●
●
60
●
● ●
20 30 40 50 60
imc
Figura 20.10: Gráfico con la función plot().
qqnorm() y qqline()
Gráfico para valorar visualmente la normalidad de una variable. Se em-
plean qqnorm() y qqline(). El paquete car contiene la función qqPlot()
más agradable y que presenta bandas de confianza [96, 120].

#---------------------------------------------------------------
qqnorm(y, ylim, main = "Normal Q-Q Plot",
xlab = "Theoretical Quantiles", ylab = "Sample Quantiles",
plot.it = TRUE, datax = FALSE, ...)
qqline(y, datax = FALSE, ...)
#---------------------------------------------------------------
Ejemplo 20.10. Gráfico Q-Q plot de la variable glu p.

> with(pima, qqnorm(glu_p))
> with(pima, qqline(glu_p, col = 2))
> with(pima, car::qqPlot(glu_p, main=’Q-Q plot with ((car))’))
Normal Q−Q Plot Q−Q plot with «car»
●●
●●●●● ● ●●
●●●●● ●
●
●●
●● ●
●●
●●
●
●
●●
● ●
●
●●
●
● ●
180
180
●
●● ●
●●
●●
●
●
●● ●●
●
●
●●
●
●
●● ●
●
●●
●
Sample Quantiles
●
●● ●
●
●●
● ●●
●
●
●
● ●
●
●
●
●
●● ●
●
●●
●
●
●
● ●
●
●
●
●
● ●
●
140
140
●
●
●●
● ●
●
●●
●
●
●
● ●
●
●
glu_p
●
●
●● ●
●
●●
●
●● ●
●
●
●
●●
● ●
●●
●
●●
●
●
●● ●●
●
●
●●
●●
●
● ●●
●
●
●●
●
● ●●
●
●
●
●
●●
●
● ●
●
●●
●
●
●
●● ●
●●
100
100
●
●●
● ●
●●
●
●●
●
●●
●
●
●● ●●
●
●●
●
●
●●
●●
●
●●
●
● ●●
●
●●
●
●
●
●
●●
●
● ●
●
●●
●
●
●
●●
●
●
● ●
●●
●
●
●
●●
●
●
●● ●
●●
●
●
●●
●●
●
●●
●
●
●● ●●
●
●●
●
●
●●
●
●
●●
● ●
●
●●
●
●●
●
●●
●
● ●●
●
●●
●
●
●
●●● ●●
●●
60
60
● ●
● ● ● ●
−3 −2 −1 0 1 2 3 −3 −2 −1 0 1 2 3
Theoretical Quantiles norm quantiles
Figura 20.11: Gráfico con la función qqnorm() y qqline() a la izquierda y con la

función qqPlot() del paquete car a la derecha.
20.4.3. Funciones para más de dos variables

pairs()
Dibuja un scatter-plot de una matriz o de un data frame.
#---------------------------------------------------------------
pairs(x, labels, panel = points, ...,
lower.panel = panel, upper.panel = panel,
diag.panel = NULL, text.panel = textPanel,
label.pos = 0.5 + has.diag/3,
cex.labels = NULL, font.labels = 1,
row1attop = TRUE, gap = 1)
#---------------------------------------------------------------
Hay varios argumentos referidos a ((panel)): lower.panel, upper.panel y di-

ga.panel. Cada uno de ellos se puede modificar para conseguir los efectos que

se desee en la región correspondiente. Por ejemplo, si se desea que en la diago-

nal además del nombre aparezca un histograma de la variable:
www.editorialuc.es
> panel.hist <- function(x) {
+ par(new = TRUE)
+ hist(x, col = ’cyan’, main = ’’)
+ }
Si se desea que en el panel superior aparezcan los coeficientes de correla-

ción:
> panel.cor <- function(x, y,

+ digits = 2, prefix = ’ ’, cex.cor
+ ) {
+ df <- na.omit(data.frame(x, y))
+ usr <- par(’usr’); on.exit(par(usr))
+ par(usr = c(0, 1, 0, 1))
+ r <- cor(df$x, df$y)
+ txt <- format(c(r, 0.123456789), digits = digits)[1]
+ txt <- paste(prefix, txt, sep = ’’)
+ if (missing(cex.cor)) cex <- 1 / strwidth(txt) # 0.8
+ test <- cor.test(df$x, df$y)
+ col_panel <- ifelse(unlist(test) < 0, 4, 2)
+ text(0.5, 0.5, txt, cex = cex * r, col = col_panel)
+ }
Ejemplo 20.11. Gráfico scatter plot matricial de las variables imc, tad y
edad.
> with(pima, pairs(˜ imc + tad + edad))
Ejemplo 20.12. Repita el ejemplo anterior, pero incorpore los histogramas

de las variables en la diagonal y los coeficientes de correlación en el panel
superior. En el panel inferior incluya la curva de regresión no paramétrica.
> with(pima, pairs(˜ imc + tad + edad,

+ diag.panel = panel.hist,
+ lower.panel = panel.smooth,
+ upper.panel = panel.cor))
interaction.plot()
Es un gráfico muy útil para visualizar la interacción.
#---------------------------------------------------------------
interaction.plot(x.factor, trace.factor, response, fun = mean,
type = c("l", "p", "b"), legend = TRUE,
trace.label = deparse(substitute(trace.factor)),
fixed = FALSE,
xlab = deparse(substitute(x.factor)),
ylab = ylabel,
ylim = range(cells, na.rm=TRUE),

40 60 80
● ●
20 30 40 50 60
● ●
● ●
● ●
● ● ● ●●●
● ●●●
● ●●● ●
●
● ●● ●
● ●●● ●●●●● ●● ●● ● ●● ●● ●●
●● ● ●●●
● ●●
imc ● ● ●
●
●●
●
●● ●●
●
●
●●
●●
●
●
●
●
●●
●●
●
●
●
●
●●
●
●●●
●●
●●●
●●
●●
●
●●
●
●
●
● ●●●●●
●●●
●●●
●●
●●
●
●●
●
●●
●
●●
●
●
●
●
●●
●
●●●● ●
●●● ●●
●● ●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●●●
●● ●
●●●
●
● ●●
●●
●
●●
●
●●
●
●●
●●
●●● ●
●
● ●
●●
●
● ●●● ● ●
●●●
●
●● ●●●●● ● ●●
●
●●●
●●● ● ●
●
●●
●●
●● ●●
●●●
● ●●●●
●
●●●●
●
●● ● ●●
●
●
●
●
●
●●
●
●
●●
●
●
●●
●
●●
● ●
●
●
●●●
●
●
●
●
●●
● ●●
●
●
●
●● ●●●●● ●●●●●
●●●●
●
●●●
●●●●
● ●
●●
●
●●●
●●
●●●●● ●
●●
●● ●●●
●
●
●●●●●
●
●
●
●●
●●
●
●
●
●
●
●●
●
●●
●
●
●
●
●
●
●
●●
●
●
●
●●
●●
●
●
●
●
●
●
●
●●●
●
● ●
●
●●
●●● ●
● ●● ●
●●● ● ● ●
●●●●●●●●●●● ●
●●●
●● ●●●●●●● ● ●● ● ● ●
●● ●●●
●●●
● ●●●●
● ●
●●
●●●
●●●●
●
●
● ● ●
●
●
●●
●●
● ●
●●
●●●●
●
●●●●●●
●● ●●●
● ●● ●● ●
●●●
● ●●●
●●● ●
●● ●●
●●● ●●
●● ● ●●
●●
● ● ● ●
●
●
●●
●●●●
●●●
●●●●
●●● ● ●●●● ● ●
●
●
●●● ●●●
●●●●
●●●
●●
●● ●
●●●
●
●● ●
●
●●●
● ●
●●●
●●
●
●●● ●
● ●● ● ● ● ●● ●
●● ●● ●
●● ●●● ●●
●●
●●●
●
●
●●
●●
●
●●
● ●●●●● ● ●
●
●
●
●●
●●
●
●
●●●●●
●●
●●●●
● ● ●● ● ●
● ●●●
●●●●● ●●●●● ●●
●●●● ●
●
●
●●
●●
●●
●● ● ● ●●
● ● ●●● ● ●
●●●●●●● ● ●
●●●● ● ● ●
●
● ● ●
● ●
● ● ● ● ● ● ● ●
●●● ●●●● ●
●● ●
● ● ● ● ● ● ●●
● ●
●
● ●
● ● ●●●● ● ●●● ●● ●● ● ●●● ●● ● ●●
● ● ●
●●
● ●●
●●●
●●●
●
●●●
●●●●●
● ●
●●● ●
●● ●●
● ●●
●●●
●
●
● ●
●
●● ●
●●
●●
●●
●●● ●
● ●●●● ●●●
●
●
●
●
●●
●●
● ●
●● ●●
●● ●●● ●
●●●● ●
●
● ● ● ● ●●●
● ●●
●● ● ● ● ●●● ●● ● ● ●●● ● ●
●
80
●● ●●
●
●
●
●●
●●
●
●
●
●●●
●●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●●
●●
●
●
●
●
●
●
●
●
●
●●●
● ●
●●●
●●●
●
●●● ● ●
●
●
●
●
●
●
●
●
●●
●
●
●
●
●
●
●
●
●
●
●
●
●●●
●●●●
●
●●
●
●
●●
●●●
●
●●
● ●●●
●
●
● ●
●●● ●●
●
● ● ●
●● ●
●
●
●●
●●●●●
●
●●
●●●
●●●
●●
●● ●
●●
●●
●
●●●
●
●
●●
●●
●
●●●
●●
●
●● ●
●● ●● ●
●● ● ●●
●
●●
●●
●
●
●●
●●
●●●
●●
●●●
●●●
●●●●●●
● ●●
●●
●● ●●● ●
●●●
●●
●●
●●
●●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●●
●
●
●
●
●●
●
●●
●
●●
●
●●●
●
●
●
●
●
●
●●●
●● tad ●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●●
●
●
●
●
●
●
●
●●
●
●●
●
●
●
●
●●
●
●
●
●
●
●
●
●●● ● ●●
●●●● ●● ●●
● ●●
60
●●
●●
●
●●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●●
●
●
●●
●●●
●●
●
●●
●
●
●
●●
●
●
●
●
●●
●●● ● ● ●
●
●
●
●
●
●
●
●
●
●
●
●
●●
●
●
●●●
●
●
●●●●
● ●
●●
●● ●●●● ● ●●
●●●●●
● ●
●
●
●●
●●●●●●
● ●● ●● ●●
●
●
●●
●●● ●
● ●●
●
● ● ●●● ●
● ●● ●
● ●●●●●●●●
●● ● ●● ●●
●
●●
●●
●
●●●● ●
●● ●● ●● ●● ●
● ●
40
● ● ● ●
● ● ● ●
● ●
80
● ●
●
● ● ●●
●
● ● ● ●
●● ●● ●● ●● ●
● ●●●●● ●●●
60
● ● ●●● ●●
●● ● ●●●● ● ●● ● ●
●●
●
● ●
●●●●
●● ●●
●● ●●● ● ●● ● ● ● ●● ●
●●
●● ●●●●
● ●●
●●●●●
●● ●
●
●●
●●●
●●●
●●
●
●●
●●
●●
●
●
●●
●
●
●
●
●●●
●●●
●
●
●●●
● ●
● ●
● ●● ●
●●● ●●
●
● ● ●●
●●●●●
●●
●●
● ●●
●
●●
●
● ●●
●●
●●●
●●●
●●●
●●
●●●●
●
●●●● ●
●●
● ● ●● ●
●●●●●●●●●
●
●
edad
●
● ●● ● ● ●●●
●● ●●●
40
●●● ●● ●
●●● ●●●●● ●
●●●●● ●●●
●
●
●
●
●●
●
●
●●●● ●●● ● ● ●●●●● ● ●●●
●
●●●● ●●
●● ●●
●●●
●●●
●
● ●
●●
●
●●
●●●● ●● ●●● ● ●
●● ●● ● ●●
● ●●●●
● ●●
●●●● ●
●
●● ●●● ●●●
● ●●●●● ● ● ● ● ●●
●●
●●●
●●
●●● ●●
●● ●●
● ●
●● ●
●●
● ● ●● ● ● ● ● ● ●●●●●● ●
●●●
● ●
●●
●●
● ●
●●●
●●
●
●●
●
●
●
●●●
●
●
●●●●
●
●
●●
●●
● ●●●●
●
●●●
● ●● ●●●●●●
●●
●●●
●●●●
●
●
●
●
●●● ●●●●●
●
●
● ●●
●●
●●●
●●●
●●●●●
●●
●●
●
●●●
●
●●●
●
●●
●
●●
●●
●
●●
● ●●
●●● ● ●
●●●●●●●●●
●●●●
●●●●
● ●
●
●●
● ●●●●
●● ●●●●
●● ●
● ●●●●●●
●●
●● ●●● ●●●●●●● ●●● ● ●● ●●
●●●●●●
●●●
●●●
● ●
●
●●●
●
●
●
●●
●
●●
●
●
●
●●
●●
●
●
●
●
●●
●
●
●
●
●
●●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●●●
●
●
●
●
●
●
●
●
●
●●
●
●●●
●
●
●
●
●
●
●●
●
●
●
● ●● ● ● ●● ●●●●●●
●●
●
●●
●●●
●●●●●
●●
●●
●
●●
●
●● ●●● ●●
● ●
●
●
●●
●●
●●
●●
●
●●
●
●
●
●●
● ●
●
●●
●●
●●
●
●
●●●
●
●●
●
●
●●
●
●●
●
● ●●●
●
●●●
●●●
● ●
●●
●
●●● ● ● ●●
●●●●
●●
●●●●
●●●
●●
●●●
●●
●
●●
●●
● ●
●●●
●●
●●
●
●
●●
●
●●● ● ●
●●
●● ●● ●
● ●●●
20
●●●●
●●●
●
●●●
●●●
● ●
●●●
● ●●
●● ●●
● ●
● ●●●● ● ●●●●●
●●●● ●●
●●●●● ●
20 30 40 50 60 20 40 60 80
Figura 20.12: Gráfico con la función pairs().
40 60 80
imc
20 30 40 50 60
150
100
0.31
Frequency
0.05
50
0
●
20 ● 40 ● ●
60 ●
●●●
●●
tad
100 150
● ● ● ●
● ●●● ●● ●● ●
● ● ●●●●
● ●●
● ●●●● ● ● ●
●
●
● ●
●●● ●
●●
●●● ●●
●●● ●
●
●
● ●● ●
● ●●
●
●●
● ●●●
● ● ●●●
●●●● ●●●● ●●
80
●● ●●●
●
●●
●●
●
●
●●●
●●
●
●●
●
●
●
●
●
●●
●
●●
●
● ●
●●
●●
●●
●●●
● ●●●
●●
●
●●●●●
●
●●●
● ●
●
●●
●
●
●
●
●
●
●●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●●
●
●
●
●
●
●●
●
●
●
●●
●
●
●●●● ● ●
●
● ●
x
●●● ●●
●●●
●
●
●●
●
●●
●
●●●
●
●●
●
●●
●
●
●
●●
●●
●
●
●●
●
●
●●
●
●●
●●
●
●
●●
●●●●
●●●
●
0.36
Frequency
●●●● ●
●●
●●
●●●
●
●●
●●
●
●●●●
●
●● ●
●●● ● ●
●● ●●●●●
●●
●
●●
●
●●●
●●
●●
●
●●●
●
●●
●
●
●●●●
●
● ●●
●
●●
●●
60
●●
●●
● ●●●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●●
●
●●●●
●●
●
●●
●
●
●
●
●
●
●
●
●
●●
●●● ● ●
●●●●●
● ●
●
●
●●
●●●●●●
● ●● ●●
●
● ● ●●●
50
● ●●●●● ●●●●● ● ●●
●● ●● ●●
40
● ●
● ●
●
0
80
●
20 40 60 ●80 120
●
● ●
● ● ●
●●
●
●
edad
●● ●● ●● ●● ●
● ●●●●● ●●●
150
60
● ● ●●● ●●
●● ● ●●●● ● ●● ● ●
●●
●
● ●
●●●●
●● ●●
●● ●●● ● ●● ● ● ● ●● ●
●● ●●● ● x●● ●
●●●●●●
●
●● ● ●
Frequency
●● ● ●●●● ●
●● ●●●●
●●● ●
●● ● ● ● ●●●● ●● ●●●●
●●● ●●● ● ● ● ●●●●●●● ●
● ●●
●● ●●●●
● ●● ●● ● ● ● ●●●●
●●●●
●●● ● ● ●● ●
●●● ●● ●
● ●
●
●●●●●●● ●●
● ●●●●● ●●●●● ●
●● ● ●●●
●● ●● ●●●
40
●● ●
●● ●
● ●
●
● ● ● ●● ● ● ●
●●●●● ●●●
●●
●
●
●
●
●
●
●
●●● ●●● ● ● ●●●●● ● ●●●
●
●●●● ●●
●● ●●
●●●
●●●
●
● ●
●●
●
●
●●●●●●● ●● ● ● ●●●
● ● ●
●●
●● ●●●●
●
●● ●
● ● ●● ●●
50
●
●● ●●● ●
●
●●
● ●●●●●
● ● ● ●
● ● ●
●●●●●●●
● ●●●●
●●● ●●
●
●● ●● ●
●●
●
●●●
●●●●●● ●●● ●● ● ● ●● ●●●●●
●
●● ●
●●
●●●●●● ●
● ● ●●
●
●●
●
●●
●
●●●
●●
●
●●
●
●
●
●
●
●
●
●●
●
●●
●
●●
●●
●●●
●
●
●
●
● ●●● ●● ● ●●●●●●
●●
●
●●
● ●●●●●●
●●●●
●●●
●● ●
●
●●●●●
●
●●
●●●
●●●
●●● ●
●●
●●
●
●●●
●●
●
●●
●●●●
● ●●●●●● ● ●●●●● ●●
●●● ●●
●●
●●
●●
● ●
●
●
●
●●
●●
●● ●●
●●●
●●
●●●
●●
●●
● ●
●
●
●
●
●
●●
●
●
●●
●●
●
●
●●
●●
●
●●
●●
●
●
●
●●
●
●
●
●
●●●
● ●●
●●● ● ●● ● ● ● ●●
●● ●●●●●●●●●●●●●
●●● ●●●
●
●●●
●
● ●
● ●
● ●
●●●
●●
●
●
●●
●
●●
● ● ●
●
●●
●
●●
●
●●●
●●●●
●
● ●
●●
● ●
●●
●●● ●●
●●●●●
●
●● ●
●●
●
●
●
●●●●
● ●
●●●●
●● ●●
●●●●
● ● ●●
●
●●●
●●●
●●
●●
●
● ●
●●
●●
●●
●
●●
●
●
●●
●●●
●
●●●●●
●●●●●
● ●●
●●● ● ●
● ●●
●●●●
●●●
●●
●● ●●●●
● ●
●●●
●● ●
●●
● ●●
●● ● ● ●
●●●
20
●●●●●●
●
●●
●●
●●●
● ●
●●●
●●●●●●●
● ●
● ●● ●
● ● ●●●●●
●●● ●●
●●●●● ●
0
20 30 40 50 60 20
20 40 60
60 80
8
0
Figura 20.13: Gráfico con la función pairs().
lty = nc:1, col = 1, pch = c(1:9, 0, letters),

xpd = NULL, leg.bg = par("bg"), leg.bty = "n",
xtick = FALSE, xaxt = par("xaxt"), axes = TRUE,
...)
#---------------------------------------------------------------

Ejemplo 20.13. Gráfico de interacción de las variables glu p, tad y diab.
www.editorialuc.es
> with(pima, {
+ x <- factor(tad > 90, labels = c(’No HTD’, ’Sı́ HTD’))
+ interaction.plot(diab, x, glu_p, legend = TRUE, col = 1:2)
+ }
+ )
x
140
No HTD
135
Sí HTD
mean of glu_p
130
125
120
115
110
N S
diab
Figura 20.14: Gráfico con la función interaction.plot().
sunflowerplot()
Cuando los puntos se solapan, una forma de solucionarlo es que vayan
saliendo pétalos en sentido radial.
#---------------------------------------------------------------
sunflowerplot(x, y = NULL, number, log = "", digits = 6,
xlab = NULL, ylab = NULL, xlim = NULL, ylim = NULL,
add = FALSE, rotate = FALSE,
pch = 16, cex = 0.8, cex.fact = 1.5,
col = par("col"), bg = NA, size = 1/8, seg.col = 2,
seg.lwd = 1.5, ...)
#---------------------------------------------------------------
Ejemplo 20.14. Gráfico de girasol de las variables Edad y Nemb.
> with(pima, sunflowerplot(edad, emb))

15
●
● ●
● ● ●●● ●
● ● ● ● ● ● ●
● ● ● ●●
10
● ● ● ●●●● ● ● ● ●● ●
emb
● ●●● ● ● ● ●●● ●● ● ●● ●● ●
● ● ●● ● ●● ●● ● ● ● ●● ●
● ●● ● ●● ●●● ● ● ● ● ●● ●● ●●
●● ● ● ● ● ● ● ●●●●● ● ● ● ● ● ●● ● ●
5
●●●● ● ● ● ● ●● ● ●● ●●●●● ●● ●●● ● ● ● ●
● ● ● ●●● ● ● ● ● ●●● ●●● ●● ● ● ●● ● ●
●● ● ● ● ● ● ●●● ● ● ● ● ● ●● ● ● ● ● ●
●●●●●●●●●●● ●● ● ●● ● ●
●●●●●●●●●●●●● ● ●● ●● ●● ●● ● ● ●
0
● ● ● ● ● ● ● ● ●●● ● ● ●● ● ● ●●
20 30 40 50 60 70 80
edad
Figura 20.15: Gráfico con la función sunflowerplot().
matplot()
Dibuja los valores de una matriz. Puede ser muy útil como paso explorato-
rio de los datos.
#---------------------------------------------------------------
matplot(x, y, type = "p", lty = 1:5, lwd = 1, lend = par("lend"),
pch = NULL,
col = 1:6, cex = NULL, bg = NA,
xlab = NULL, ylab = NULL, xlim = NULL, ylim = NULL,
..., add = FALSE, verbose = getOption("verbose"))
#---------------------------------------------------------------
Ejemplo 20.15. Gráfico mat-plot de las variables glu p, tad y emb.
Figura 20.16: Gráfico con la función matplot().
> with(pima, {
+ M <- cbind(glu_p, tad, emb)
+ matplot(M, pch=16)}
+ )

cdplot()
Es un gráfico de conditional density para una variable cualitativa que depen-
www.editorialuc.es
de de una numérica.
#---------------------------------------------------------------
cdplot(x, y,
plot = TRUE, tol.ylab = 0.05, ylevels = NULL,
bw = "nrd0", n = 512, from = NULL, to = NULL,
col = NULL, border = 1, main = "", xlab = NULL, ylab = NULL,
yaxlabels = NULL, xlim = NULL, ylim = c(0, 1), ...)
#---------------------------------------------------------------
Ejemplo 20.16. Gráfico cdplot de las variables diab y emb.
> with(pima, cdplot(diab ˜ emb))
1.0
S
0.8
0.6
diab
0.4
N
0.2
0.0
5 10 15
emb
Figura 20.17: Gráfico con la función cdplot().
mosaicplot()
Un mosaic-plot consiste en la visualización de las frecuencias observadas
mediante rectángulos cuya área es proporcional a la frecuencia [196, 197]. Per-
mite representar datos categóricos relacionados mediante una fórmula [198].
#---------------------------------------------------------------
mosaicplot(x, main = deparse(substitute(x)),
sub = NULL, xlab = NULL, ylab = NULL,
sort = NULL, off = NULL, dir = NULL,
color = NULL, shade = FALSE, margin = NULL,
cex.axis = 0.66, las = par("las"),
type = c("pearson", "deviance", "FT"), ...)
#---------------------------------------------------------------
Ejemplo 20.17. Gráfico mosaic-plot de las variables diab y obe.

Diabetes vs. Obesidad
N S
No OB
obe
Obesidad
diab
Figura 20.18: Gráfico con la función mosaicplot().
> with(pima, {
+ obe <- factor(imc > 30, labels = c(’No OB’,’Obesidad’))
+ mosaicplot(diab ˜ obe, main=’Diabetes vs. Obesidad’)}
+ )
Los mosaic-plots siguen siendo una herramienta valiosa [199]. De acuerdo

con Ünlü et al.mosaic plots are state-of-the-art graphics for multivariate categorical
data in statistical visualization)) [200].
spineplot()
Muy similar al anterior.
#---------------------------------------------------------------
spineplot(x, y = NULL,
breaks = NULL, tol.ylab = 0.05, off = NULL,
ylevels = NULL, col = NULL,
main = "", xlab = NULL, ylab = NULL,
xaxlabels = NULL, yaxlabels = NULL,
xlim = NULL, ylim = c(0, 1), axes = TRUE, ...)
#---------------------------------------------------------------
Ejemplo 20.18. Gráfico spine-plot de las variables diab y obe.
> with(pima, {
+ spineplot(diab ˜ obe, main=’Diabetes vs. Obesidad’)}
+ )
assocplot() y fourfoldplot()
Es una función útil para hacer gráficos con tablas de contingencia de dos
dimensiones, en cada celda se calcula la diferencia entre el valor observado (O)
y el esperado (E); cada rectángulo tiene una altura proporcional a esta dife-
rencia y una anchura proporcional a la raı́z cuadrada del valor esperado, por
lo que su área es proporcional a la diferencia (O − E), colocando el rectángulo

Diabetes vs. Obesidad
www.editorialuc.es
1.0
S
0.8
0.6
diab
0.4
N
0.2
0.0
No OB Obesidad
obe
Figura 20.19: Gráfico con la función spineplot().
por encima de la lı́nea si esta diferencia es positiva y por debajo si es nega-

tiva. La función fourfold() [201] también genera un gráfico para tablas de
contingencia en el que representa la OR y su intervalo de confianza.
#---------------------------------------------------------------
assocplot(x, col = c("black", "red"), space = 0.3,
main = NULL, xlab = NULL, ylab = NULL)
fourfoldplot(x, color = c("#99CCFF", "#6699CC"),
conf.level = 0.95,
std = c("margins", "ind.max", "all.max"),
margin = c(1, 2), space = 0.2, main = NULL,
mfrow = NULL, mfcol = NULL)
#---------------------------------------------------------------
Ejemplo 20.19. Gráfico assoc-plot y fourfold-plot de las variables diab y obe.
> with(pima, {
+ tabla <- table(diab, obe)
+ opar <- par(mfrow = c(1, 2))
+ assocplot(tabla)
+ fourfoldplot(tabla)
+ par(opar)
+ })
smoothScatter()
Produce una versión suavizada de un gráfico de puntos.
#---------------------------------------------------------------
smoothScatter(x, y = NULL, nbin = 128, bandwidth,
colramp = colorRampPalette(c("white", blues9)),
nrpoints = 100, pch = ".", cex = 1, col = "black",
transformation = function(x) xˆ.25,
postPlotHook = box,
xlab = NULL, ylab = NULL, xlim, ylim,

diab: N
197 218
No OB
obe: Obesidad
obe: No OB
obe
Obesidad
N S
40 174
diab diab: S
Figura 20.20: Gráfico con la función assocplot() a la izquierda y con

fourfoldplot() a la derecha.
xaxs = par("xaxs"), yaxs = par("yaxs"), ...)

#---------------------------------------------------------------
Ejemplo 20.20. Gráfico smoothScatter de las variables imc y ptri.

100
80
60
ptri
40
20
20 30 40 50 60
imc
Figura 20.21: Gráfico con la función smoothScatter().
> with(pima, smoothScatter(imc, ptri))
image()
Dibuja imágenes de niveles de color.
#---------------------------------------------------------------
image(x, y, z, zlim, xlim, ylim, col = heat.colors(12),
add = FALSE, xaxs = "i", yaxs = "i", xlab, ylab,
breaks, oldstyle = FALSE, ...)
#---------------------------------------------------------------

Ejemplo 20.21. Gráfico de niveles de color con image().
www.editorialuc.es
> x <- 10 * (1:nrow(volcano))
> x.at <- seq(100, 800, by=100)
> y <- 10 * (1:ncol(volcano))
> y.at <- seq(100, 600, by=100)
> image(x, y, volcano, col = terrain.colors(100), axes = FALSE)
Figura 20.22: Gráfico con la función image().
contour()
Esta función dibuja curvas de nivel. Se suele utilizar en conjunción con
image().
#---------------------------------------------------------------
contour(x = seq(0, 1, length.out = nrow(z)),
y = seq(0, 1, length.out = ncol(z)),
z,
nlevels = 10, levels = pretty(zlim, nlevels),
labels = NULL,
xlim = range(x, finite = TRUE),
ylim = range(y, finite = TRUE),
zlim = range(z, finite = TRUE),
labcex = 0.6, drawlabels = TRUE, method = "flattest",
vfont, axes = TRUE, frame.plot = axes,
col = par("fg"), lty = par("lty"), lwd = par("lwd"),
add = FALSE, ...)
#---------------------------------------------------------------
Ejemplo 20.22. Gráfico de curvas de niveles con contour().
> x <- 10 * (1:nrow(volcano))

> x.at <- seq(100, 800, by=100)

> y <- 10 * (1:ncol(volcano))

> y.at <- seq(100, 600, by=100)
> image(x, y, volcano, col = terrain.colors(100), axes = FALSE)
> contour(x, y, volcano, levels = seq(90, 200, by = 5),
+ add = TRUE, col = "brown")
> axis(1, at = x.at)
> axis(2, at = y.at)
> box()
> title(main = "Maunga Whau Volcano",
+ sub = "col = terrain.colors(100)", font.main = 4)
Maunga Whau Volcano
col = terrain.colors(100)
Figura 20.23: Gráfico con las funciones image() y contour().
persp()
Esta función permite crear gráficos tridimensionales.
#---------------------------------------------------------------
persp(x = seq(0, 1, length.out = nrow(z)),
y = seq(0, 1, length.out = ncol(z)),
z, xlim = range(x), ylim = range(y),
zlim = range(z, na.rm = TRUE),
xlab = NULL, ylab = NULL, zlab = NULL,
main = NULL, sub = NULL,
theta = 0, phi = 15, r = sqrt(3), d = 1,
scale = TRUE, expand = 1,
col = "white", border = NULL, ltheta = -135, lphi = 0,
shade = NA, box = TRUE, axes = TRUE, nticks = 5,
ticktype = "simple", ...)
#---------------------------------------------------------------
Ejemplo 20.23. Gráfico de niveles tridimensionales con la función persp().
z <- 2 * volcano # Exaggerate the relief

x <- 10 * (1:nrow(z)) # 10 meter spacing (S to N)

y <- 10 * (1:ncol(z)) # 10 meter spacing (E to W)
www.editorialuc.es
persp(x, y, z, theta = 120, phi = 15, scale = FALSE, axes = FALSE)
title(main = "Maunga Whau\nOne of 50 Volcanoes in the Auckland Region.",
font.main = 4)
Maunga Whau
One of 50 Volcanoes in the Auckland Region.
Figura 20.24: Gráfico con la función persp().
heatmap()
Permite gráficos bidimensionales con dendogramas.
#---------------------------------------------------------------
heatmap(x, Rowv=NULL, Colv=if(symm)"Rowv" else NULL,
distfun = dist, hclustfun = hclust,
reorderfun = function(d,w) reorder(d,w),
add.expr, symm = FALSE, revC = identical(Colv, "Rowv"),
scale=c("row", "column", "none"), na.rm = TRUE,
margins = c(5, 5), ColSideColors, RowSideColors,
cexRow = 0.2 + 1/log10(nr), cexCol = 0.2 + 1/log10(nc),
labRow = NULL, labCol = NULL, main = NULL,
xlab = NULL, ylab = NULL,
keep.dendro = FALSE, verbose = getOption("verbose"), ...)
#---------------------------------------------------------------
Ejemplo 20.24. Gráfico heatmap de color con heatmap().
> with(pima, {
+ M <- cbind(diab, obe, emb)

+ heatmap(t(M[1:10, ]))
+ M[1:10, ] }
+ )
diab obe emb
[1,] 1 2 5
[2,] 2 1 7
[3,] 1 2 5
[4,] 1 2 0
[5,] 1 1 0
[6,] 2 2 5
[7,] 1 2 3
[8,] 1 1 1
[9,] 1 2 3
[10,] 2 2 2
Figura 20.25: Gráfico con la función heatmap().
Hay más funciones gráficas que iremos viendo a lo largo de los próximos
capı́tulos.
20.5. Funciones gráficas de bajo nivel

Estas funciones enriquecen un gráfico existente, es decir, no crean un gráfi-
co nuevo, sino que añaden algún elemento enriquecedor a un gráfico ya exis-
tente. Ya hemos visto que para dibujar la lı́nea de densidad en un histograma,
previamente tenı́amos que dibujar el histograma; luego la función density()
debiera estar incluida en este apartado.
Vamos a ver unos cuantos, pero solo nombrarlo y cómo se ejecutan:
20.5.1. Puntos
points()
Dibuja puntos.

20.5. FUNCIONES GRÁFICAS DE BAJO NIVEL 241
#---------------------------------------------------------------
points(x, y = NULL, type = "p", ...)
www.editorialuc.es
#---------------------------------------------------------------
20.5.2. Lı́neas
abline()
Dibuja lı́neas.
#---------------------------------------------------------------
abline(a = NULL, b = NULL, h = NULL, v = NULL, reg = NULL,
coef = NULL, untf = FALSE, ...)
#---------------------------------------------------------------
arrows()
Dibuja flechas.
#---------------------------------------------------------------
arrows(x0, y0, x1 = x0, y1 = y0, length = 0.25, angle = 30, code = 2,
...)
#---------------------------------------------------------------
lines()
Dibuja lı́neas, no necesariamente rectas.
#---------------------------------------------------------------
lines(x, y = NULL, type = "l", ...)
#---------------------------------------------------------------
polygon()
Dibuja polı́gonos uniendo puntos definidos por sus coordenadas.
#---------------------------------------------------------------
polygon(x, y = NULL, density = NULL, angle = 45,
border = NULL, col = NA, lty = par("lty"),
..., fillOddEven = FALSE)
#---------------------------------------------------------------
Ejemplo 20.25. En una escala de 0:10 en abscisas y 0:100 en ordenadas, dibuje

los puntos A(2, 25), B(4, 63) y C(9, 90). Dibuje una lı́nea y = a + b*x con a =
16.64 y b = 8.54.
> plot(x = c(0, 10), y = c(0, 100), ty=’n’,

+ xaxt = ’n’, xlab = ’’,
+ yaxt = ’n’, ylab = ’’)
> axis(1)
> axis(2)

100
●
80
●
60
40
●
20
leyenda
0
0 2 4 6 8 10
Figura 20.26: Funciones de bajo nivel.
> grid()
> points(2, 25, pch = 16, col = 2)
> points(4, 63, pch = 16, col = 3)
> points(9, 90, pch = 16, col = 4)
> abline(16.64, 8.54, lwd = 3, col = 5)
> arrows(1, 80, 4, 64)
> lines(c(2, 4, 9), c(25, 63, 90), lt=2)
> legend(6, 20, ’leyenda’, fill = ’yellow’)
segments()
Dibuja segmentos.
#---------------------------------------------------------------
segments(x0, y0, x1 = x0, y1 = y0,
...)
#---------------------------------------------------------------
20.5.3. Ejes
axis()
Dibuja los ejes.
#---------------------------------------------------------------
axis(side, at = NULL, labels = TRUE, tick = TRUE, line = NA,
pos = NA, outer = FALSE, font = NA, lty = "solid",
lwd = 1, lwd.ticks = lwd, col = NULL, col.ticks = NULL,
hadj = NA, padj = NA, ...)
#---------------------------------------------------------------
box()
Dibuja un marco para el gráfico.
#---------------------------------------------------------------
box(which = "plot", lty = "solid", ...)
#---------------------------------------------------------------

20.5. FUNCIONES GRÁFICAS DE BAJO NIVEL 243
grid()
Dibuja una rejilla en punteado gris para una mejor lectura de los gráficos.
www.editorialuc.es
#---------------------------------------------------------------
grid(nx = NULL, ny = nx, col = "lightgray", lty = "dotted",
lwd = par("lwd"), equilogs = TRUE)
#---------------------------------------------------------------
20.5.4. Texto
legend()
Dibuja leyendas (tan necesarias en un gráfico).
#---------------------------------------------------------------
legend(x, y = NULL, legend, fill = NULL, col = par("col"),
border="black", lty, lwd, pch,
angle = 45, density = NULL, bty = "o", bg = par("bg"),
box.lwd = par("lwd"), box.lty = par("lty"),
box.col = par("fg"),
pt.bg = NA, cex = 1, pt.cex = cex, pt.lwd = lwd,
xjust = 0, yjust = 1, x.intersp = 1, y.intersp = 1,
adj = c(0, 0.5), text.width = NULL, text.col = par("col"),
merge = do.lines && has.pch, trace = FALSE,
plot = TRUE, ncol = 1, horiz = FALSE, title = NULL,
inset = 0, xpd, title.col = text.col)
#---------------------------------------------------------------
mtext()
Dibuja texto en los márgenes del gráfico.
#---------------------------------------------------------------
mtext(text, side = 3, line = 0, outer = FALSE, at = NA,
adj = NA, padj = NA, cex = NA, col = NA, font = NA, ...)
#---------------------------------------------------------------
rect()
Dibuja rectángulos definidos por sus coordenadas.
#---------------------------------------------------------------
rect(xleft, ybottom, xright, ytop, density = NULL, angle = 45,
col = NA, border = NULL, lty = par("lty"), lwd = par("lwd"),
...)
#---------------------------------------------------------------
text()
Escribe un texto en una posición determinada.

#---------------------------------------------------------------
text (x, y = NULL, labels = seq_along(x), adj = NULL,
pos = NULL, offset = 0.5, vfont = NULL,
cex = 1, col = NULL, font = NULL, ...)
#---------------------------------------------------------------
title()
Escribe un tı́tulo en un gráfico.
#---------------------------------------------------------------
title(main = NULL, sub = NULL, xlab = NULL, ylab = NULL,
line = NA, outer = FALSE, ...)
#---------------------------------------------------------------
20.6. Funciones interactivas

Se utilizan para identificar datos especı́ficos o colocar anotaciones. Hay dos:
20.6.1. Lectura de coordenadas

locator()
Lee las coordenadas del lugar donde se pulsa el botón izquierdo del ratón.
#---------------------------------------------------------------
locator(n = 512, type = "n", ...)
#---------------------------------------------------------------
20.6.2. Identificación de puntos

identify()
Identifica los puntos y les puede asignar una etiqueta.
#---------------------------------------------------------------
identify(x, y = NULL, labels = seq_along(x), pos = FALSE,
n = length(x), plot = TRUE, atpen = FALSE, offset = 0.5,
tolerance = 0.25, ...)
#---------------------------------------------------------------
20.7. Gráficos condicionales

Llegados a este punto, vamos a ver un tipo de gráficos condicionales coplot()
consistente en un plot(x, y) por cada una de las categorı́as de una variable
cualitativa, o de una variable numérica categorizada (con solapamiento):
#---------------------------------------------------------------
coplot(formula, data, given.values, panel = points,
rows, columns,

20.7. GRÁFICOS CONDICIONALES 245
show.given = TRUE, col = par("fg"), pch = par("pch"),

bar.bg = c(num = gray(0.8), fac = gray(0.95)),
www.editorialuc.es
xlab = c(x.name, paste("Given :", a.name)),
ylab = c(y.name, paste("Given :", b.name)),
subscripts = FALSE,
axlabels = function(f) abbreviate(levels(f)),
number = 6, overlap = 0.5, xlim, ylim, ...)
#---------------------------------------------------------------
Ejemplo 20.26. Represente gráficamente el imc versus WAIST condicionado

por el sexo (utilizaremos la BdD BD familias.csv).
Given : sex
50 60 70 80 90
●
30
●
●
● ● ● ●
●● ●
25
●● ●
imc
●
● ●● ● ●
●
20
●
● ●
●
● ●
●●
● ●
●●
15
●
●
●●
50 60 70 80 90
waist
Figura 20.27: Gráfico IMC vs. Cintura con la función coplot().
> with(familias, coplot(imc ˜ waist | sex))
Missing rows: 6, 13, 16, 19
Ejemplo 20.27. Represente gráficamente el IMC versus Ptri condicionado

por la Edad (utilizaremos la BdD PimaESP.xls).
> with(pima, coplot(imc ˜ ptri | edad))
Missing rows: 201, 202, 203, 204, 205, 206, 207, 208, 209, 210,
211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223,
224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236,
237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249,
250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262,
263, 264, 265, 266, 267, 268, 269, 270, 272, 273, 274, 275, 276,
277, 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, 289,
290, 291, 292, 293, 294, 295, 296, 297, 298, 299, 300

Given : edad
30 40 50 60 70 80
20 40 60 80 20 40 60 80
60
●● ● ● ●
●● ● ● ●●●● ● ● ● ● ●● ●
●●●●● ● ●
● ●●
●● ●
●
●● ● ● ●●
● ●●●
40
●● ● ● ●
● ●
● ●
● ●●
●●
●●●
● ●●●●●
● ●
●●●●● ●●● ●●●
● ●●●
● ●● ●● ●● ●●●●●
● ● ●●●
●● ●●
● ●●
● ●●
●
●●
●
●
●●
●●
●
●
●●
●
●
●
●●
●
●
●
●
●● ●
●
●
●●
●●●
●●●
●●
●●●
●●
●
●
●●●●●
●●
● ●●
●
●
●
●
●
●
●
●
●
●●
●●
●
● ●● ●
●●●
● ●
●●●●●●● ● ● ● ●●● ●
●● ● ● ●
● ● ●●
●●
●● ●
●● ●●
●● ●
● ● ●●●
●●● ●●● ●● ●●●
●●
●
● ●
●
●●●●●
●
●●
●●●●● ●
● ●
●● ●●
●● ●●●
●●●
●
●●
●●
●● ●● ●●
● ●
●●
● ●●●●
●
●
●●●
●
● ● ●
● ●●
●
● ●●
●●
●●●●● ●●● ●● ●●●●
●●●●●●
●●●
●● ● ● ● ●●
●●
●●
●●
●● ●● ● ● ●● ●
● ●
● ●● ● ●●
●● ● ●● ●
●● ● ●
● ● ●●●●
20
●●
● ● ●
imc
● ●
60
● ●
● ●
● ●
● ● ● ●
●● ●●
● ●
●●● ●●●●●●
●● ● ●●● ●●●● ●
●● ●
●● ●● ●
●
● ●● ● ●● ●● ●●● ●●● ●●●
40
● ●
●● ● ●●●●●● ●●●●● ●●●
● ●● ●● ● ●● ●● ●●●●
●
● ●
●
● ●●●
●●●●●●●●
●●●● ●
●●●
●
●●
●●●●
●
●●●
●
●●● ● ●●
●●
●●
●
●●
●●●●● ●● ●●
●● ●
● ●●● ●
●●
● ● ●●
● ●
●●●
●
●●
●
●●●●●
●
●●●
●
●
●●
● ● ● ●
●●●
●●
●
●●●
● ● ●●●
●
●●
●
●●●
●
●
●
●● ● ●●
●●
●●●●●● ●
● ●
● ●●● ●
●●
●
● ●
●●●●● ●●● ●
●●
● ●● ●
● ●
●●●●
●●●
●
●●●●●
●●
●
● ●●●●●
●
●●
●●●●
●
●
●
●
●
●●
●
●
●
●
●
●●
●●●●
●●●●●
●●
●●
●
●
●●●●●
●●● ●
●
●
●
●●
●
●●
● ●●
●
●●
● ●●● ●
●
●
●
●●
●
●
●
●●
●●
●●
●●● ● ●●
● ●
●●●
● ●●● ●●
●●●
●●●
● ●
● ●
●● ●
● ●●
●● ●● ●
●●●●
●
●●
●
●
●
●
●●●●●●●● ●
●●●●●
●
●●
●
●● ●
●●●●●
●
● ● ●●●●
●●
●●●
●
●●●
● ●● ●
●
●●●●●
● ● ●● ●● ● ● ●
20
●● ●
●●●●
●●
● ●●● ●●● ●●●●● ●
20 40 60 80
ptri
Figura 20.28: Gráfico IMC vs. Ptri condicionado por la Edad, con la función
coplot().
20.8. Gráficos dinámicos

Rotan gráficos tridimensionales. Hay varios paquetes que se ocupan de es-
tos menesteres y que pueden encontrarse en la ((Task View: Graphic Displays
and Dynamic Graphics and Graphic Devices and Visualization)) (en este libro
no los vamos a tratar).
20.9. Matriz de correlaciones

Las matrices de correlaciones son difı́ciles de interpretar si hay muchas y
tienen muchos decimales. Para resolver esto ayuda muchı́simo una buena re-
presentación gráfica de dichas matrices.
Ejemplo 20.28. Calcule la matriz de correlaciones de las variables edad, peso,

talla, fmd, fmi, fmax e imc y grafı́quelas.
> M <- cor(.data[, c(3, 8:13)])

> round(M, 2)
edad peso talla fmd fmi fmax imc
edad 1.00 0.42 0.52 0.39 0.40 0.41 0.19
peso 0.42 1.00 0.67 0.58 0.58 0.59 0.83

20.9. MATRIZ DE CORRELACIONES 247
talla 0.52 0.67 1.00 0.66 0.66 0.67 0.16

fmd 0.39 0.58 0.66 1.00 0.93 0.99 0.27
www.editorialuc.es
fmi 0.40 0.58 0.66 0.93 1.00 0.96 0.27
fmax 0.41 0.59 0.67 0.99 0.96 1.00 0.28
imc 0.19 0.83 0.16 0.27 0.27 0.28 1.00
Figura 20.29: Matriz de correlaciones en adolescentes de 12 a 17 años. Las variables

son edad, peso, talla, fmd, fmi, fmax, imc.
so
ad
ax
la
c
i
pe
ed
fm
fm
fm
tal
im
1
edad ● 0.8
peso 0.6
0.4
talla ● 0.2
fmd ● 0
−0.2
fmi ● −0.4
fmax
● −0.6
● ● ●
−0.8
imc ● ●
−1
Visualmente se aprecia que la fuerza máxima se correlaciona positivamente

con la fuerza de la mano derecha e izquierda (como era de esperar) y que el
IMC se correlaciona con el peso y mucho menos con la talla.
Por supuesto, en vez de cı́rculos se podı́a haber puesto elipses que descri-
ben mejor las nubes de puntos, y también el propio coeficiente.

talla, fmd, fmi, fmax e imc. y dibuje las correlaciones con elipses.
> corrplot(M, tl.srt = 60, tl.col = ’black’,
+ method = ’ellipse’, addCoef.col = ’black’)


son edad, peso, talla, fmd, fmi, fmax, imc. Se dibujan elipses.
so
ad
ax
la
c
i
pe
ed
fm
fm
fm
tal
im
1
edad 1 0.42 0.52 0.39 0.4 0.41 0.19
0.8
peso 0.42 1 0.67 0.58 0.58 0.59 0.83 0.6
0.4
talla 0.52 0.67 1 0.66 0.66 0.67 0.16
0.2
fmd 0.39 0.58 0.66 1 0.93 0.99 0.27 0
−0.2
fmi 0.4 0.58 0.66 0.93 1 0.96 0.27
−0.4
fmax 0.41 0.59 0.67 0.99 0.96 1 0.28 −0.6
−0.8
imc 0.19 0.83 0.16 0.27 0.27 0.28 1
−1
20.10. Mapas
Con R es sencillo crear mapas. En el campo de las Ciencias de la Salud tie-
nen aplicación cuando se quieren presentar datos epidemiológicos [202–206].

> Fcant(1)
> Fcant(2)

20.10. MAPAS 249
Figura 20.31: Mapa de la Comunidad de Cantabria (izquierda) y de las comarcas de

Cantabria (centro) y de los municipios de Cantabria (derecha).
www.editorialuc.es
tablas:
Función Acción
abline() Dibuja una lı́nea
arrows() Dibuja una flecha
attr() Para cambiar los atributos de un objeto
barplot() Gráfico de barras
boxplot() Gráfico de cajas y bigotes
codebook() Descripción de las variables de una BdD según el
paquete epicalc
contents() Atributos de las variables de una BdD según el pa-
quete Hmisc
des() Estadı́stica descriptiva de una BdD según el pa-
quete epicalc
describe() Estadı́stica descriptiva de una variable según el
paquete Hmisc
dim() Dimensiones de un objeto
duplicated() Comprueba si hay duplicados
factor() Convierte una variable en factor

Función Acción
Fcomplete cases() Missings en una BdD
FleeXLS() Lee una BdD en formato excel
hist.data.frame() Histogramas de una BdD según el paquete Hmisc
identify() Identifica un punto
invisible() No muestra el resultado de una función
label.var() Etiqueta una variable según el paquete epicalc
levels() Fija los niveles de un factor
log() Logaritmo de una variable
max() Máximo de un vector
mtext() Pone un texto debajo del tı́tulo, en el margen supe-
rior
numeric() Crea un vector numérico
pairs() Gráficos de puntos de una BdD
par() Fija determinados parámetros gráficos
paste() Pega varios elementos en una cadena
read.csv2() Lee un fichero csv en español
recode() Recodifica una variable según el paquete epicalc
replace() Reemplaza un valor de un elemento por otro valor
shapiro.test() Prueba de normalidad de una variable
summ() Estadı́stica descriptiva de una variable según el
paquete epicalc
summary() Resumen de un vector
tab1() Descriptiva de una variable cualitativa según el
paquete epicalc
table() Crea una tabla
rainbow() Colores del arcoiris
text() Escribe texto en una posición determinada
transform() Transforma una variable
use() Fija en memoria y usa una BdD según el paquete
epicalc
zap() Borra objetos de la memoria según el paquete
epicalc
Función Acción
maps Mapas package [207]
tabplot Gráfico de grandes bases de datos [191]

PROBLEMAS
www.editorialuc.es
Problema 1. Empleando la BdD ((pima)), represente la nube de puntos formada por
las variables imc (variable independiente) y glu p (variable dependiente) mediante
puntos sólidos de color verde para las mujeres no diabéticas y de color rojo para las que
lo son. Añada una lı́nea de regresión lineal de color azul y de doble grosor. Rotule las
variables como ((IMC (kg/m2 ))) y ((Glucemia (mg/dL))) y ponga como tı́tulo ((Glucemia
e IMC en indias Pima (1988))) y como subtı́tulo ((Graficado por -su nombre-)) e iden-
tifique los cuatro sujetos con mayor IMC.
Problema 2. Represente el mapa de la Comunidad de Cantabria.

www.editorialuc.es
Capı́tulo 21
Gráficos Trellis
Los gráficos ((trellis)), basados en ideas de Cleveland [208] creados por Sar-
kar, amplı́an las capacidades gráficas de R por su especial énfasis en los gráfi-
cos multivariantes [189], de ahı́ su amplia utilización en citometrı́a [209], far-
macocinética [210], bioinformática [211].
Para poder ((disfrutar)) de estos gráficos hay que cargar previamente el pa-
quete lattice. Hay muchos tipos de gráficos, análogos a los gráficos tradi-
cionales, pero con más ((glamour)) (Tabla 21.1).
Tabla 21.1: Gráficos trellis y gráficos tradicionales
Gráfico Gráfico
tradicional trellis Descripción
cloud() Gráficos tridimensionales
densityplot() Gráfico de densidad condicional
parallel() gráficos paralelos
barplot() barchart() Gráfico de barras
boxplot() bwplot() Gráfico boxplot
contour() contourplot() Gráficos de contornos
dotchart() dotplot() Gráfico de puntos
hist() histogram() Histograma
image() levelplot() Gráficos de niveles
pairs() splom() Gráficos de matrices
persp() wireframe() Gráficos tridimensionales
plot() xyplot() Gráfico de nubes de puntos
qqnorm() qqmath() Gráfico quantil-quantil teóricos
qqplot() qq() Gráfico quantil-quantil reales
stripchart() stripplot() Gráfico de puntos de una dimensión
Una de las importantes cualidades de estos gráficos es su capacidad de rea-

lizar gráficos condicionales
253
254 CAPÍTULO 21. GRÁFICOS TRELLIS
21.1. Uso básico

Para generar un gráfico ((trellis)) se necesita una formula:
y v x | cond
y Es la variable dependiente.
v Es la tilde que define que lo escrito sea una fórmula.
x Es la variable independiente.
| Es lo que define que lo que sigue es lo que marca la condición.
cond Es la variable condicional. Puede ser una o más, en cuyo caso están se-
paradas por el signo ((+)) o ((*)).
21.2. Gráficos de ejemplo

21.2.1. Histogramas
Para dibujar un histograma se utiliza la función histogram().
#---------------------------------------------------------------
histogram(x,
data,
allow.multiple, outer = TRUE,
auto.key = FALSE,
aspect = "fill",
panel = lattice.getOption("panel.histogram"),
prepanel, scales, strip, groups,
xlab, xlim, ylab, ylim,
type = c("percent", "count", "density"),
nint = if (is.factor(x)) nlevels(x)
else round(log2(length(x)) + 1),
endpoints = extend.limits(range(as.numeric(x),
finite = TRUE), prop = 0.04),
breaks,
equal.widths = TRUE,
drop.unused.levels =
lattice.getOption("drop.unused.levels"),
...,
lattice.options = NULL,
default.scales = list(),
default.prepanel =
lattice.getOption("prepanel.default.histogram"),
subscripts,
subset)
#---------------------------------------------------------------
Ejemplo 21.1. Represente un histograma de la fuerza máxima para cada uno

de los años de edad en los varones.

21.2. GRÁFICOS DE EJEMPLO 255
> use(DATA)
> edad_c <- factor(floor(DATA$edad), labels=paste(12:17, ’años’))
www.editorialuc.es
> label.var(edad_c, ’Edad en años cumplidos’)
> histogram(˜ fmax | edad_c, data = .data[sexo == ’Masculino’, ])
20 30 40 50 60
15 años 16 años 17 años

40
30
20
Percent of Total
10
0
40
30
20
10
0
20 30 40 50 60 20 30 40 50 60
fmax
Figura 21.1: Histograma de la fuerza máxima en los varones según su edad.
21.2.2. Gráficos de densidad

Para dibujar un histograma se utiliza la función densityplot().
#---------------------------------------------------------------
densityplot(x,
data,
allow.multiple = is.null(groups) || outer,
outer = !is.null(groups),
auto.key = FALSE,
aspect = "fill",
panel = lattice.getOption("panel.densityplot"),
prepanel, scales, strip, groups, weights,
xlab, xlim, ylab, ylim,
bw, adjust, kernel, window, width, give.Rkern,
n = 50, from, to, cut, na.rm,
drop.unused.levels =
lattice.getOption("drop.unused.levels"),
...,
default.scales = list(),

default.prepanel =
lattice.getOption("prepanel.default.densityplot"),
subscripts,
subset)
#---------------------------------------------------------------
Ejemplo 21.2. Represente un gráfico de densidad de la fuerza máxima para

cada uno de los años de edad en las mujeres.
> densityplot(˜ fmax | edad_c, data = .data[sexo == ’Femenino’, ])
10 20 30

0.15
0.10
0.05
Density
●
●●
●●●
●
● ●
●
●●
●
●●●
●●●
●
●●● ●
●
● ●
●
● ●
●●
●●●
●
●
●●
●
●●
●●
●
●
●●
● ●●
●●
● ●
●●
●●●●
●●
●●●●
● ●
● 0.00
0.15
0.10
0.05
0.00 ● ●●
●
●●
●●
●
●●
●●
●●● ●
●● ● ●●
● ●
●
●●●
●● ●●
●
●●●
●●●
●
●●●
●
●
●●● ●
●
● ● ● ●●
●
● ●
●●
● ●
●
●●
●●●●
●●
●●● ●
10 20 30 10 20 30
fmax
Figura 21.2: Densidad de la fuerza máxima en las mujeres según su edad.
También es posible ((apilar)) las curvas de densidad.
Ejemplo 21.3. Represente en un mismo gráfico las curvas de densidad de la

fuerza máxima de los varones para cada año de edad.
> densityplot(˜ fmax, data = .data[sexo == ’Masculino’, ],

+ groups = edad_c, plot.points = FALSE,
+ ref = TRUE, auto.key = list(edad_c))
21.2.3. Gráficos boxplot

La función equivalente a boxplot() en los gráficos ((trellis)) se llama bwplot().

www.editorialuc.es
Figura 21.3: Densidad de la fuerza máxima en los varones según su edad.
#---------------------------------------------------------------
bwplot(x,
data,
outer = FALSE,
auto.key = FALSE,
aspect = "fill",
panel = lattice.getOption("panel.bwplot"),
prepanel = NULL,
scales = list(),
strip = TRUE,
groups = NULL,
xlab,
xlim,
ylab,
ylim,
box.ratio = 1,
horizontal = NULL,
drop.unused.levels = lattice.getOption("drop.unused.levels"),
...,
default.scales,
default.prepanel = lattice.getOption("prepanel.default.bwplot"),
subscripts = !is.null(groups),
subset = TRUE)
#---------------------------------------------------------------
Ejemplo 21.4. Describa mediante un gráfico boxplot el número de embara-

zos de las indias pima.

> bwplot(˜ emb, data = pima,

+ xlab = ’Embrazos’)
● ● ● ●
0 5 10 15
Embrazos

zos de las indias pima según sean o no diabéticas.
> bwplot(diab ˜ emb, data = pima,

+ ylab = ’Diabetes’, xlab = ’Emabarazos’)
S ●
Diabetes
N ● ● ●
0 5 10 15
Emabarazos

zos de las indias pima según sean o no diabéticas, condicionado a cómo sea
su estado nutricional.
> en <- cut(imc, breaks = c(min(imc), 18.5, 25, 30, max(imc)),

+ include.lowest = TRUE, right = FALSE,
+ labels = c(’DE’, ’EU’, ’SO’, ’OB’))
> bwplot(diab ˜ emb | en, data = pima,
+ ylab = ’Diabetes’, xlab = ’Embarazos’,
+ layout = c(4, 1))

0 5 10 15 0 5 10 15
www.editorialuc.es
DE EU SO OB
S ● ● ● ●
Diabetes
N ● ● ●● ● ●● ● ● ●
0 5 10 15 0 5 10 15
Emabarazos
21.2.4. Gráficos violinplot

Una tarea común en estadı́stica es comparar las distribuciones de las va-
riables y una herramienta empleada es el gráfico boxplot y mejor aún con un
gráfico de densidad (densityplot). Desafortunadamente es difı́cil comparar va-
rios de estos gráficos a la vez. Para solucionar este problema Hintze inventó el
violin plot, que consiste en la combinación de un boxplot con dos lı́neas de den-
sidad [212]. Algo parecido en gráficos tradicionales es el beamplot que sı́ permite
apreciar los outliers [?, 213]
Este tipo de gráficos se crea con la función bwplot(), añadiendo el paráme-
tro panel = panel.violin.
Ejemplo 21.7. Describa mediante un gráfico violinplot el número de emba-

razos de las indias pima según sean o no diabéticas, condicionado a cómo
sea su estado nutricional.
> bwplot(diab ˜ emb | en, data = pima,

+ ylab = ’Diabetes’, xlab = ’Emabarazos’,
+ panel = panel.violin,
+ layout = c(4, 1))
21.2.5. Gráficos de barras

Cuando se quiere representar una variable cualitativa el gráfico de barras
es el indicado. Se debe utilizar la función barchart(). Este tipo de gráficos,
junto con los de tartas son muy populares, pero como ya hemos comentado
anteriormente, los estadı́sticos desaconsejan los gráficos de tartas [195,214,215],

0 5 10 15 0 5 10 15
DE EU SO OB
S
Diabetes
0 5 10 15 0 5 10 15
Emabarazos
en el paquete lattice no existe [189], igual que no se nombra en el libro de

Venables y Ripley [102].
#---------------------------------------------------------------
barchart(x,
data,
panel = lattice.getOption("panel.barchart"),
default.prepanel = lattice.getOption("prepanel.default.barchart"),
box.ratio = 2,
...)
#---------------------------------------------------------------
Ejemplo 21.8. Represente gráficamente la distribución de las indias pima

según número de embarazos y diabetes.
> tabla <- table(pima$emb, pima$diab)

> addmargins(tabla)
N S Sum
0 60 33 93
1 97 25 122
2 74 16 90
3 40 24 64
4 41 19 60
5 28 14 42
6 26 11 37
7 16 18 34
8 10 16 26
9 7 14 21

10 8 9 17
11 2 6 8
www.editorialuc.es
12 4 4 8
13 4 2 6
14 0 2 2
15 0 1 1
17 0 1 1
Sum 417 215 632
> barchart(tabla, groups = FALSE)
0 20 40 60 80 100
N S
17
15
14
13
12
11
10
9
8
7
6
5
4
3
2
1
0
0 20 40 60 80 100
Freq
Figura 21.8: Número de embarazos y diabetes en las indias Pima.
21.2.6. Diagramas de puntos

Los gráficos de puntos (dot plots) [194, 195, 216] constituyen una manera
sencilla de resumir la información contenida en una tabla y debieran utilizarse
con más frecuencia [189].
Los gráficos de puntos se logran con la función dotplot().
#---------------------------------------------------------------
dotplot(x,
data,
panel = lattice.getOption("panel.dotplot"),
default.prepanel = lattice.getOption("prepanel.default.dotplot"),
...)
#---------------------------------------------------------------
Ejemplo 21.9. Represente la proporción de diabetes según el número de em-

barazos de las indias Pima mediante un gráfico de puntos.
> x <- tabla[, 2] / rowSums(tabla)

> dotplot(x, type = c(’o’, ’p’),
+ main = ’Embarazos y diabetes’,
+ ylab = ’No de embarazos’, xlab = ’Frecuencia’)

Embarazos y diabetes
17 ●
15 ●
14 ●
13 ●
12 ●
Nº de embarazos
11 ●
10 ●
9 ●
8 ●
7 ●
6 ●
5 ●
4 ●
3 ●
2 ●
1 ●
0 ●
0.2 0.4 0.6 0.8 1.0
Frecuencia
Figura 21.9: Porcentaje de diabetes en las indias Pima según el número de embarazos.
21.2.7. Scatter plots

Son los gráficos más importantes en estadı́stica1 . Dibuja en un sistema de
coordenadas cartesianas dos variables numéricas [217]. En los gráficos trellis
se crean con la función xyplot().
#---------------------------------------------------------------
xyplot(x,
data,
outer = !is.null(groups),
auto.key = FALSE,
aspect = "fill",
panel = lattice.getOption("panel.xyplot"),
prepanel = NULL,
scales = list(),
strip = TRUE,
groups = NULL,
xlab,
xlim,
ylab,
ylim,
drop.unused.levels = lattice.getOption("drop.unused.levels"),
...,
default.scales,
default.prepanel = lattice.getOption("prepanel.default.xyplot"),
subscripts = !is.null(groups),
subset = TRUE)
#---------------------------------------------------------------
1 En palabras de Sarkar: ”The scatter plot is possibly the single most important statistical graphic”
[189].

Ejemplo 21.10. Represente mediante una nube de puntos colocando en abs-

cisas el IMC y en ordenadas la TAD de las indias Pima, presentando dos
www.editorialuc.es
nubes de puntos, una para las diabéticas y otra para las normales.
> xyplot(tad ˜ imc | diab,

+ type = c(’p’, ’g’, ’smooth’), #aspect = ’iso’,
+ pch = 21, cex = 1, fill = ’cyan’, lwd = 2,
+ xlab = ’IMC (kg/mˆ2)’, ylab = ’TAD (mm Hg)’,
+ data=pima)
20 30 40 50 60
N S
●
● ● ● ●
● ● ●
● ● ●● ●
100 ● ●
● ●● ● ● ● ● ●
●● ● ● ●●
● ●● ●●●● ●●●●● ● ● ● ●●●●●●●
●●●
●
● ● ●●● ●
●● ● ●
●● ● ●● ●●
TAD (mm Hg)
●●
●●●● ●●
● ●● ● ●
● ● ●● ●●● ●
● ● ●●●●●
●●●●
●
●
● ●●●
●
●
●
●●●
● ●●●
●
●●●●●●
●●●●
●● ●●
●● ●●●● ●● ●●
●● ●●●
●
●●
●
● ● ●●
●
●
●
●
80 ●● ●● ●● ●
●●● ●●●●
● ●
●
●
●●●
●●
●
●
●
●
●
●
●
●
●●
●●
●
●
●
●●
●
●
●
●
●
●●
●
●
●
●●●●
●●
●
●
●● ●●●●
●
● ●●●●●●●
●● ●
●●●
●● ●
●● ●
●●● ●●●●
● ●● ●
● ●
●
●●● ●● ●●●
●● ●● ●
●● ●●
●●●●●●
●●
●●●●● ●●● ●●● ●
●●●●
●● ●● ●
●● ●
●●
●●●
●●
●●●●
●
● ●
●●
●
●●●●
●
●
●● ●● ●
●● ●●● ● ● ●●●
●●
●●
●●
●
●●
●●●
●
●● ●
●●●
● ●
●
●●
●● ●●●●●
●● ●●●●●
●●●●
●
●●●
●●●●
●●● ●●●●●●
● ● ● ● ● ● ●● ●● ●●●●●
● ●● ●●●●
60 ●●●
●●
●●●
●
●●
●
●
●●
●
●●●
●
●
●
●●
●●●
●
●
●
●●
● ●●
●●●●●
●●● ● ●
●●● ●● ●●●● ●
●
●●●
● ●●●●
●
●●●
●●●●●
● ●●●●●●●●●
● ● ● ●
●● ●●● ● ● ● ●
● ●● ● ● ● ● ●● ● ● ● ●● ● ●
●●
40 ● ●
● ●
●
20
20 30 40 50 60
IMC (kg/m^2)
Figura 21.10: Relación entre TAD e IMC en las indias Pima según la presencia de
diabetes.
Se aprecia como la TAD va aumentando conforme aumenta el IMC. En el

gráfico se ha añadido una linea de regresión no paramétrica.
En otras ocasiones, imitando a la función pairs() de los gráficos tradicio-
nales, se puede utilizar la función splom() del paquete lattice.
#---------------------------------------------------------------
splom(x,
data,
auto.key = FALSE,
aspect = 1,
between = list(x = 0.5, y = 0.5),
panel = lattice.getOption("panel.splom"),
prepanel,
scales,
strip,
groups,
xlab,
xlim,
ylab = NULL,
ylim,
superpanel = lattice.getOption("panel.pairs"),
pscales = 5,
varnames = NULL,

drop.unused.levels,
...,
default.scales,
default.prepanel = lattice.getOption("prepanel.default.splom"),
subset = TRUE)
#---------------------------------------------------------------
Ejemplo 21.11. Represente en una matriz gráfica las variables 2:6 y 8 de la

BdD de las indias pima.
> splom(pima[, c(2:6, 8)])
● ● ● ● ●
●●● ● ●● ● ● ● ●●
●● ● ●● ● ●
● ● ● ●● ● ●
●●●
●●● ●● ●●
●●●● ●
●
●● ●●
●●
●
● ●●
●
●
●
●
●
●● ●
●●●●● ●
● ●
●●
●
●
●
●●
●
●
●●
●●
●
●●●● ●●●●
●
●
●
●
●
●
●
●●●●● ● ●●●
●
●●
●
●
●
●●
●
●●
●
●
●●
● ●
●●●
●●●●● ●● ●● ●
● ● ●●● ●●
●●● ●●● ● ●
●●● ● ●● ●●● ●
●●
●
●
●●●
●●●
●●●●●
●●●
●●●●
●
●●
●●●
●● ●●● ● ●●●
●●
●●●● ●●●
●
●
●
●●●●
●
●
●●●
●
●
●
●
●●●
●
●
●●
●
●
●
●●
●
●
●●●●●
●●●
●●
●●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●●
●
●
●●
●
●●●
● ● ●
●
●
●
●● ● ●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●●
●
●
●
●
●
●
●
●●
●●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●●
●● edad
●●
●●
● ●●
●
●
●
●
●
●
●
●●●
●
●●
●●
●
●
●
●
●
●
●●
●● ●
●●
●
●
●
●
●
●
●
●
●
●●
●
●
●
●●
●
●
●
●
●
●
●
●
●
●
●
●●
●
●●
●
●
●
●
●●
●
●
●
●
●
●●●●●
●●
●
●
●
●
●
●●● ●
●
●●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●●
●
●
●
● ●
●● ●
●●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●●
●
●
●
●
●
●
●
●
●
●
●
● ●
●
●●
●
●
●●
●
●●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●●
●
●●
●
●
●
● ●
●● ●●
●●●●
●●●● ● ●● ●● ● ● ●● ●●● ●●
●●●
● ● ● ● ●● ● ● ●●●
●●
●●●●
●
●
●
●●
●
●
●
●●
●●
●
●●
●●
●●
●●●●●
●● ● ●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●●
●
●
●
●
●
●●
●
●
●
●
●
●
●
●
●
●
●
●●●
●
●
●
●
●
●
●
●●
●
●
●
●
●
●●●
●
●●●●● ● ●
●●●●
●
●
●
●
●
●
●
●
●●
●
●
●
●
●
●
●
●
●
●
●
●●
●
●
●
●
●
●
●
●
●
●
●
●
●
●●
●
●
●
●
●
●
●
●●
●
●
●
●
●
●
●
●
●
●● ● ●
●●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●●
●
●●●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
● ● ●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●●
●
●
●
●
●
●
●
●
●
●
●
●●●
●●● ●
●
●●
●●●●
●●
●
●●
● ●●●
●● ●●●●
●
●●
●
●
●
●●
●
●
●
●
●●
●
● ●
●
●
●●
●
●
●●
●
●
●
●
●●
●
●
●●●●
●
●
●
●
●●
●
●●●
●●
●●
●
●●● ●
●
●●●
● ●● ● ●●●
●
●●
●
●
●
●●
●
●
●
●●●
●
●
●●
●●
●●
●
●
●
●●
●
●
●
●●
●●
●●
●
●
●
●
●●
●
●
●●
●
●●● ●
●
● ●
●
●●
●
●
●●
●
●
●
●●
●
●
●
●●●
●
●
●●
●●
●●
●
●●●
●
●
●●●
●
●●
●
●●
●
●●
●
●
●●● ●●
●
●
●
●●
●
●
●
●●
●
●
●
●
●
●●
●
●
●
●●
●
●
●
●●
●
●●
●●
●
●
●
●
●●
●
●
●
●●
●●
●
●
●●
●
●
●
●●●
● ●
●
● ● ● ● ●
● ● ● ● ● ● ● ● ●●
●● ● ● ● ● ● ● ●● ●● ●
●
●
●● ●●●● ●● ● ●●●● ●
●●
●
●● ●●●●●●
●
●
● ●●●
●●
●
●
●●●●●
●●
● ●●●●
●●●●●●●●●●●●● ●● ●
●●● ●
● ● ●●● ●●●
●
●●
●
●●●
●
● ● ●
●●●
● ●●● ●
●●
●
●
●●● ●●
● ●●
●
●
●
●
●
●●
●
●●
●
●●
●●
●●
●
●●●
● ●●
●●
●
●●●
●●
●●
●●●
●●●●
●●●●
●
●
●●●●● ●●●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
● ●
●
●
●
●
●
●●
●
●
●●
●●
●
●
● ●●●
●
● ●
●
●●●
●●●
●●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●●●
●
●
●●●
●● ●●
●
● ● ●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●●
●●
●●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
● ●
imc ●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●●
●
●
●
●
●
●●
●●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●●
●
●
●
●
●
●
●
●●
●
●
●
●
●
●●
●
● ●
●● ● ●●●●●
●●● ● ●
●
●●● ●●
● ●
●●
● ●●●●
● ● ●
● ● ●●●
●●
●●
●●●
●●
●
●●
●● ●●● ● ●
●●●
●●
● ●
●●
●●● ●
●●
●●
●●●●
●●●
●
●
●● ●●
● ● ●●
●
●●
●●
●●
●
●●●
●●
●
●●●●●
●●
●●
●● ●●● ●●
●
●
●
●●
●
●●
●●●
●
●
●
●●
●
●●
●●
●
●
●●
●
●●
●●
●
●
●
●●
●
●●
●
●● ●●●
●●
●● ● ●
●
● ●●
●
●
●
●●
●
●
●●
●
●
●●
●
●
●
●
●
●●
●
●
●
●
●
●
●
●
●
●●
●
●
●●
●
●
●
●● ● ●●●
●
●
●●
●
●
●
●
●
●
●
●
●●
●
●
●●
●
●
●
●
●
●●
●●●
●
● ● ●
●
●
●
●
●
●
●
●
●
●
●
●
●●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●●
●
●
●
●
●●
●
●
●●
●
●
●
●●
●
●●●
● ●
●
●●
●
●
●
●●●
●●
● ●●●●
●●
●●●●●●
●●
●●
●
●●
●
●●
●●
●
●
●●
●
●●
●
●
●●
●
●
●●
●●
●
●
●
●
●
●
●
●
●●
●
●
●●●●● ●● ●● ●
●
●
●●
●
●
●●
●
●●
●
●
●
●
●●
●●●
●
●
●
●●
●
●
●
●
●
●●
●
● ●
●
●
●
●●
●●
●
●
●●
●●
●●
●
●
●
●
●●
●
●
●
●
●● ●
●
●
●
●●
●
●
●
●●
●
●
●
●
●
●
●
●
●
●●
●
●
●●
●
●●
●
●●
●
●●●●●
●●● ●
●
●●
●●
●●●●●●
●●
●
●
● ●● ● ●●●
●●
●
●
●
●
●
●
●
●●
●
●
●
●
●●
●
●
●
●●
●● ●●
● ●●●
●
●
●
●
●
●●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●●●●
●● ●
●
●
●
●
●
●
●
●
●
●
●
●
●●●
●
●
●
●
●
●
●
●
●
●
●
●
●
●●
●
●
●●●
●● ●
●● ●●
● ●
● ● ● ● ●
●
● ●● ●● ● ●● ● ●●
●●●●● ●●● ● ●● ● ●●● ●● ●●
●●
●● ●● ptri ●
●●
●●●●●● ●
●
●●● ●● ●
●●
●●
●●●●●●
●●
● ●●
●● ●
●●
●● ●●●
●● ● ● ●● ●
●●
●
●
●
●
●
●
●
●
●
●
●
●●
●●●
●
●
●
●●
●●
●●●
●
●
●
●
●
●
●●
●●
●
●●●
●●●
●● ●
●●●●
●● ●●
●
●
●
●
●
●
●
●
●●
●
●●
●
●
●●
●
●
●
●
●
●
●
●●
●
●
●
●
●
●
●
●●●●
●● ●● ●●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●●
●
●
●
●
●●●
●
●●
●●● ● ●
● ●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●●
●
●
●●
●
●
●
●
●
●
●
●
●
●
●●
●●
●●●●●●
●
●●
●●
●●
● ●●●
●●● ●●●
●●●●●●
●● ● ●●●
●
●
●●
●●
●
●
●●
●●
●●●
●
●●●
●
●
●●●
●●
●●
●●●
●●
●
●●
●● ●●●
●
● ●
● ●●●
●
●
●
●
●●
●
●
●
●
●●
●
●
●●
●
●
●●
●
●
●●
●●●
●
●
●●●
● ●●●
●
●
●●
●
●
●●
●
●
●●
●
●●
●
●●
●
●
●●
●
●
●●
●●
●
●
●●
●●●●
● ●
●
●
●
●
●●●
●
●
●
●
●●
●
●
●
●
●●
●●
●
●
●
●●
●
●
●●●
●●
●
●
●●●
●
●●●
●●●
● ●
●
●●●
●●●●●●
●●
●●●●●
●●
● ●
●●●●
●●● ●● ●●
●
●●
●
●●
●
●●
●
●●
●
●●
●
●●●
●●
●
●
●●
●●●
●●●
●
●●
●●●
●●●
●
●●● ●●●
●●
●●
●
●
●●
●
●
●
●●
●●
●
●
●●
●
●●
●
●
●
●●
●●
●
●
● ●● ● ●
●●
●
●
●●
●
●
●
●
●●
●
●
●
●●
●
●
●●
●
● ●
●●
●
●
●●
●
●
●
● ●●
●
● ●
●
●
●
●
●●
●
●
●
●●
●
●
●
●●
●
●●
●
●
●●
●
●
●
●
●●
●
●●●
●
● ●
●
●●
●
● ●
●
●●●
●
●
●●
●●
●●
● ●
●●
●●
●●
●●
● ●
●●
●
●
●●●
●●
●●●●
● ●● ●●
●●
●
●
●
●
●
●
●●
●
●
●
●
●
●
●
●
●
●
●
●●
●
●
●●
●●
●
●●
●
●
●
●●
●
●
●●
●
●
●●●
●
●
●
●● ●●●●●●●
●● ● ●●
●●
●
●
●
●
●●●
●●
●
●
●
●●
●
●
●
●
●●
●●
●
●
●
●
●
●
●
●
●
●
●
●●●
●●
●
●
●●
●●
●
●● ●● ●
●
●
●
●●
●●
●
●
●
●
●
●●
●
●
●●
●
●
●
●
●●
●
●
●
●
●
●
●
●
●
●
●
●
●●
●
●
●●●● ● ●
●
●
●
●
●●
●
●
●
●
●
●●
●
●●
●
●
●
●
●
●
●
●
●
●
●●
●
●●
●
●
●
●
●
●
●
●
●●
●
●
●
●
●●
●●
●
●●
●
●
●
●●●
● ●●
●
●●
●● ●●●
●● ● ●
●●●●
●●●
●
●
● ●●
● ● ●●●●●●
●
●●●
●
●
● ● ●
●
● ●
●
●●
●●●
●
●●
●
●●
● ●
●
●●
●●
●
●●●● ● ●
● ●● ● ● ● ● ●● ● ●●●● ● ●● ● ●● ● ● ● ●● ●
●●
●●● ● ● ●●● ● ●● ● ● ● ●● ●●●●● ●●●● ●● ●● ●● ●●●●
●● ●● ● ●
●● ● ● ● ●
●
●●●●
●
●●
●●
●●●
●●
●● ●●●●●●●
● ●●
●●
●
●
●●●
● ●
●
● ●
●●
●
●●
●
●
●
●
●●
●
●
●
●
●
●●
●●
●●
●●
●
●
●●
●
●
●●●
●
●●
●
●●
●
●
●●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●●
●● ●● ●●
●●●●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●●
●●
●
●●
●●●
●●● ●
●
●
●
●
●●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●●
●
●●
●
●
●●
●●
●
●
●●
●
●
●
●
●
●
●●
●
●
●●●
●
●
●●●
●●●●●●
●●
●● ●
●● ●
●●●●
●● ●● ●●●
●●●● ●
●●●
●
●●
●
●●
●
●
●●
●
●
●●●●
●
●●
●●●
●
●●●
●●
●
●●●●
●●
●●●
●
●● ●●
●
●
●●
●●
●
●
●●
●
●
●●
●
●
●
●●
●
●
●●
●
●●●● ● ●●●
●
●
●●
●●
●
●
●●
●
●●
●
●●
●
●●
●●●
●●
●●
●●●● ● ● ●
●
●
●
●●
●
●
●●
●
●
●
●●
●●
●
●
●
●●
●●
●●
●●
●
●●
●●
●●
● ●
● ●● ●
●
●
●
●
●
●●
●
●●●
●
●●
●● ●
●
●●
●●●
●●●
●●
●● ●
●
●
●
●●
●
●
●
●
●
●
●●
●
●
●●
●
●●
●●
●
●
●
●
●
●
●●
●
●
●
● ●
●●
●
●
●
●
●
●
●●
●●
● ●●
●
● tad ●●●
●
●
●●
●
●
●
●●
●
●
●●
●
●●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●●●
●●
●●● ●
●
●●
●●
●
●●
●●
●
●
●
●●
●
●
●●
●●
●
●
●
●
●●
●
●
●
●
●
●
●
●●
●
●
●
●
●
●
●
●
●●●
●
●●
●
● ●
●
●●
●
●
●
●
●
●
●
●
●
●
●
●
●●●
●
●
●
●●
●
●
●
●
●
●
●
●
●
●
●
●●
●
●●
●
●
●●
●●
●
●
●
●
●
●
●
●●
●●
●
●●
●
●
●
●
●
●
●
●●
●
●●
●
●
●●●
●
●●
●●
●●●●
●●●●●●
●●●●
●● ●●
●
●
●●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●●
●
●
●
●
●
●
●●●
●
●
●●●●
●
●●●
●●●
●
●●● ●●
●
●
●
●●
●●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●●
●
●
●
●
●
●
●
●
●
●●● ●
●
●
●
●
●
●
●
●
●
●
●●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●●
●
●
●
●
●●
●●
● ●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●●
●
●
●
●
●
●
●
●
●
●
●●
●
●
●
● ●●●
●●●●
●● ●● ●
●●●●●●●●●
●
●●●● ●● ● ●●
●● ●●
●●
●●
● ● ●
●●
●●
●
●
●●
●●●
●●
●●● ●
●
●
●●
●
●●
●●●
●●
● ● ●●
●●● ●
●● ● ● ●●
● ● ● ● ●●
●
● ●
●
●
● ●● ● ● ●
● ● ● ● ●●●
●●
●●●●●●●
●● ●● ●●● ●
● ● ●● ●●
●● ●●
●●●
● ● ● ●●●
● ●
●●
● ●● ●●●
●●●●●● ●●● ●
●●
● ●
●● ●●
●
●● ●
●● ●●
●
●
●●
●● ●
●●●
●●● ● ●
●
● ●
●●
●
●●
●●
●
●
●
●
●
●
●●● ● ●
●●
●
●●
●●
●
●●
●●●●
●
● ● ● ●
●
●●
●●●●
●
● ●●
●● ●●
●
●●
●
●●
●
●●
●●●●●●●
●● ●● ● ●
●●
●
●●
●
●
●●
●
●
●●
●●●
●
● ●● ● ●
●●
●
●●
●●
●
●●
●
●
●
●
●●
●
● ● ●●
●● ●
●
●
●
●
●●
●●
●
●●●●
●●
●●●●
●
●
●●
●
●
●
●●
●
●●
●●
●
●
●●●●●●●
●
●●●
●
●●●● ●
●● ●●
●● ●●●●● ●●● ●
●
●●
●
●●
●●●
● ●
●●
● ●●
●●
●●
●
●
●
●
●●
●
●
●●
● ● ●●
●
●
●
●●●
●
●
●●●
●●
● ●●●
● ●
●●
●●
●
●
●
●●
●●
●
●
●●
●
●
● ●
●
●
●●
● ●●●
●●
● ●●
●●● ●● ●●
●● ●●● ● ● ●
●
●●●●
●
●●●
●
●
●
●
●●●
●●
● ●
●
●●
●●
●
●●
●●
● ●
●●
●●
●●● ●
●●●
●
●●
●
●●
●● ●
●
● ●
●●
●●
● ●
●
●●
●
●●
●
●
●
● ●●
●●● ●
●
●●
●● ●●●●
●
●
●
●
●
●
●
●●●●
●
●●●●
●●
●
● ●
●
●
●●●●
●●● ● glu_p ●●●
●
●● ●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●●
●
●
●
●
●
●●
●
●
●
●
●
●
●
●
●
●●●●● ●●
●
● ●●
●
●
●
●
●
●
●
●●
●
●
●●
●
●
●
●
●
●
●
●
●
●
●
●
●
●●●
● ●●●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●●
●●●● ● ● ● ●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●●
●
●
●
●
●
●●
●
●
●
●
●
●
●
●
●
●
●
●
●
●●
●
●
●
●●
●
●
●
●
●●
●
●●
●
●●●● ●
●
● ● ●● ● ● ●● ●
●● ●
●● ●● ●● ●●● ● ●
●●
●●
●
●
●●
●●
●●
●
●●
●●●
●●●
●●●
●●●●●
●●●●●●● ●
●●●●
●●●
●●●
●
●
●
●
●
●
●●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●● ●
●●● ● ●
●
●●
●
●●
●●
●
●
●
●
●●
●
●●
●
●
●●
●
●●●
●
●
●
●
●
●
●
●●
●●
●
●
●
●
●●●● ●●
●
●●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●●
●●
●
●
●
●
●
●
●
●● ● ●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●●
●
●●●●●
●●●●●
●●●
●●
●●●●
●●●
●
●●●●●● ● ● ●● ●●●●
●●●
●
●
●
●
●
●
●
●
●
●
●
●
●
●●
●
●
●
●●
●
●
●
●
●●
●●
●
●● ● ●●
●
●
●
●
●
●
●
●●
●
●
●
●
●
●●
●
●●
●
●●
● ●
●
●
●●●
●●●
●
●
●
●
●●
●●
●●
●
●●
●
●
●
●
●
●
●
●
●
●●
●
●●
●
●
●
●
●
●●
●
●●●
● ●
●
●
●
●
●
●
●
●
●
●●
●
●
●
●
●●
●
●●
●
●●
●●
●●
●
●
●●
●●●● ●●
●
●●
● ●●
●●
●●
●● ●
● ●●●●
● ● ●
●
●
●
●
●
●●
●
●
●●
●
●
●
●●
●●●
●
●
●
●
●●●
● ●
●
●
●
●
●●
●●
●
●●
●●
●
●
●●
●
● ●●
●
●●
●
●●
●
●
●●
●
●
●
●
●●
●
●
●●
●
●
●
●
●
●
●●●●● ● ●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●●
●
●
●
●
●
●
●●●●
●● ●●
● ●
● ●● ● ● ●●●● ●●● ●
●
● ●
●●
●
●
● ●
●
●● ●●
● ●
●
● ● ● ● ●
● ● ● ● ●● ●●● ●●●
● ● ●●
●●●●●●● ● ●
●●● ●
●●●●
●
●●●
●●● ● ●●
● ●● ●
●●
●●● ●●●●●
● ●●
●●●
● ●
●●
●●
●
●●
●● ●
●●
●●
● ●●●
●
● ●
● ● ●● ●
● ●● ●●● ●
● ●
●●
● ● ●●
●● ● ● ●●●●●
●
●●● ●●●●
●●
●
●●●
●
● ●●
●
●●
●●●●● ●●
●●
●
●●
●
●
●
●●
●●
●
●
●●
●
●
●● ●●●● ●
●●
●●
●
●
●●
●●
●
●
● ●
●● ●● ●
●
●●
●
●●
●
●
●●
●●
●
●●
● ●●●
● ●●●
●
●
●
●●
●
●●
●
●
●●
●
●●
●
●●
●●
●
●●
●●●● ●
emb ●●
●●
●
●●
●
●
●
●
●
●
●●
●
●
●
●
●
●
●
●
●●●
●
●
●
●●
●
●
●
●
●
●●●
●
●
●
●
●
●●●
●●
● ●●
●●
●●
● ●● ●
●●
●●
●●
●
●
●
●●
●
●●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●●
●●
●
●
●
●●
●● ●●●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●● ●●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●●●●
●
● ●● ●●
●●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●●
●
●
●
●
●
●
●●
●
●
●●
●●●
●
●
●
●
●
●
●●●
●
●●
●
●
●●●
●
●●
●
●●
●●
●
●
●
●●
●●
●
●●
●
●
●
●●●
●
●
●●●
●
●●
●
●
●●
●●● ●
●
●● ●●
●
●
●
●●
●
●
●
●
●●
●●
●
●
●
●●
●●
●
●
●●
●
●●
●●● ●
● ●●●
●
●●
●
●
●
●●
●
●
●●
●
●●
●
●
●●
●
●●
●● ●●●
●
●●
●
●●
●
●
●
●
●●
●
●
●●
●●
●
●
●●
●
●
●
●
●●
●●●
●
●●●● ●
●
●●
●
●
●
●
●●
●
●
●
●
●
●
●●
●
●●
●
●
●
●
●
●●
●
●
●●
●●
●
●●●
●●●
●●●●
●
●●●
● ●
●
●●●
●
●●●
●
●
●
●
●●
●
●●
●
●
●
●●
●
●
●
●●●
●
●
●●
●
●
●●●
●
●●
●●●
●●
● ●
●
●●
●●●
● ●●
●●
●
●●
●
●●
●●
●
●
●●
●
●
●
●●
●
●●
●
●●●
●●
●
●
●
●
●●
●●
●
●
●●
●
●
●●
●
●
●●
● ● ●
●●
●
●
●
●●
●●
●
●
●●
●
●●
●●
●
●
●●●
●
●
●
●
●●
●
●
●
●●●●
● ●
●
●●
●●
●
●
●●
●●●
●
●
●
●
●
●●
●
●
●
●
●●
●
●
●
●
●●
●
●
●●
●
●
●
●●
●
●
●
●
●●
●●●
●
●● ● ●
●
●
●
●
●●
●
●
●
●
●●
●●
●
●
●
●
●
●
●●
●
●●
●
●
●
●●
●
●●●● ●
●●●
● ● ●
●
●●
●●
●
●●●
●●
●
●
●
●
●●●
●
●●●
●
●
●
●
●
●●
●●
●
●●
●●
●
●
●
●
●●
●●
●
●
●
● ●
●
●●●●
●
●●●●
●●●●●
●
● ●●
●●● ●●
● ●●●
●
● ●●●
●
●●●
●
●●
●
●
●●
●●
●
● ●
●●
●
●
● ●
●
●
●●●
●●
●
●
●●
●
●
●●
●●
●●
● ●● ●
●●●● ●●●
●
●●
●
●●
●
●●
●●
●
●●
●●
●
●●●
●
●●
●●●
●
●
●●
●
●●
●
●●
●
●
●
●●
●
●●
●
●●● ●
●● ●
●●
●
●●
●●
●
●●
●●
●
●
●
●●
●
●
●
●
●●●
●
●
●
●
●●
●
●●
●●
●
●
●
●
●●
●
●
●
●●
●
●●
●
●
●●
●
●●
●
●
●●●
●●
●●● ● ●
●
●
●
●
●●
●●
●●
●
●
●
●●
●
●
●
●
●
●●
●
●
●●
●
●
●
●●
●
●●
●
●●
●●●
● ● ●
●
Scatter Plot Matrix
Figura 21.11: Gráfico de la BdD de indias Pima, con la función splom().
Ejemplo 21.12. Represente en una matriz gráfica las variables 2:6 y 8 de la

BdD de las indias pima, diferenciando entre las que tienen diabetes y las que
no.
> splom(˜ pima[, c(2:6, 8)] | diab, data=pima, pch = ’.’,

+ type = c(’p’, ’smooth’, ’g’), pscales = 0,
+ col = 4)
21.2.8. Gráficos tridimensionales

Los gráficos tridimensionales en lattice se obtienen con la función cloud().

N S
www.editorialuc.es
edad edad
imc imc
ptri ptri
tad tad
glu_p glu_p
emb emb
Scatter Plot Matrix
Figura 21.12: Gráfico de la BdD de indias Pima, con la función splom(); a la iz-
quierda las no diabéticas y a la derecha las diabéticas..
#---------------------------------------------------------------
cloud(x,
data,
outer = FALSE,
auto.key = FALSE,
aspect = c(1,1),
panel.aspect = 1,
panel = lattice.getOption("panel.cloud"),
prepanel = NULL,
scales = list(),
strip = TRUE,
groups = NULL,
xlab,
ylab,
zlab,
xlim = if (is.factor(x)) levels(x) else range(x, finite = TRUE),
ylim = if (is.factor(y)) levels(y) else range(y, finite = TRUE),
zlim = if (is.factor(z)) levels(z) else range(z, finite = TRUE),
at,
drape = FALSE,
pretty = FALSE,
drop.unused.levels,
...,
default.scales =
list(distance = c(1, 1, 1),
arrows = TRUE,
axs = axs.default),
default.prepanel = lattice.getOption("prepanel.default.cloud"),
colorkey,
col.regions,
alpha.regions,
cuts = 70,

subset = TRUE,
axs.default = "r")
#---------------------------------------------------------------
Ejemplo 21.13. Represente la relación entre el pringue tricipital, el IMC y la

existencia de diabetes en las indias Pima.
Figura 21.13: Gráfico de la BdD de indias Pima, con la función cloud().
> cloud(imc ˜ ptri + diab, data = pima, groups = diab)
21.2.9. Matriz de correlaciones

En los gráficos ((trellis)) se implementan con la ficción levelplot() ade-
cuando la función panel.
Ejemplo 21.14. Represente en una matriz gráfica las correlaciones de las

variables 2:6 y 8 de la BdD de las indias Pima.
> panel.corrgram <- function(

+ x, y, z, subscripts, at,
+ level = 0.9, label = FALSE, ...
+ ) {
+ require(’ellipse’, quietly = TRUE)
+ x <- as.numeric(x)[subscripts]

1.0
www.editorialuc.es
edad 64 28 35 16 7 100
imc 1 25 31 65 100 7 0.5
ptri 10 23 23 100 65 16
0.0
tad 20 22 100 23 31 35
glu_p 13 100 22 23 25 28 −0.5
emb 100 13 20 10 1 64
−1.0
emb glu_p tad ptri imc edad
Figura 21.14: Matriz de correlaciones en la BdD de indias Pima.
+ y <- as.numeric(y)[subscripts]
+ z <- as.numeric(z)[subscripts]
+ zcol <- level.colors(z, at = at, ...)
+ for (i in seq(along = z)) {
+ ell <- ellipse(z[i], level = level, npoints = 50,
+ scale = c(0.2, 0.2),
+ centre = c(x[i], y[i]))
+ panel.polygon(ell, col = zcol[i], border = zcol[i], ...)
+ }
+ if (label)
+ panel.text(x = x, y = y, lab = 100 * round(z, 2),
+ cex = 0.8, col = ifelse(z < 0, ’white’,
+ ’black’))
+ }
>
> cor_pima <- cor(pima[, c(2:6, 8)], use = ’complete.obs’)
> levelplot(cor_pima, at = do.breaks(c(-1.01, 1.01), 20),
+ xlab = ’’, ylab = ’’,
+ colorkey = list(space = ’right’),
+ panel = panel.corrgram, label = TRUE)

21.2.10. Mapas
Los gráficos ((Trellis)) también tienen capacidad de crear mapas condiciona-
les con la función mapplot().
Ejemplo 21.15. En la librerı́a latticeExtra está la BdD USCancerRates

con las tasas de muerte por 105 habitantes detalladas hasta nivel de conda-
dos (hay 3041 observaciones). Se va a representar gráficamente. Nota: este
ejemplo está tomado del libro de Sarkar [?].
Muertes por cáncer

Tasa anual / 100000 habitantes
Figura 21.15: Muertes por cáncer.
> library(lattice)
> library(latticeExtra)
> library("mapproj")
> data(USCancerRates)
> rng <- with(USCancerRates,
+ range(rate.male, rate.female, finite = TRUE))
> nbreaks <- 40
> breaks <- exp(do.breaks(log(rng), nbreaks))
> mapplot(rownames(USCancerRates) ˜ rate.male + rate.female,
+ data = USCancerRates, breaks = breaks,
+ map = map("county", plot = FALSE, fill = TRUE,
+ projection = "tetra"),
+ scales = list(draw = FALSE), xlab = "",
+ main = ’Muertes por cáncer\n
+ Tasa anual / 100000 habitantes’)

tablas:

www.editorialuc.es
Función Acción
addmargins() Calcula los marginales en una tabla o matriz
barchart() Gráfico de barras
boxplot() Gráfico boxplot
bwplot() Gráfico boxplot
c() Concatena elementos en un vector
cloud() Gráficos tridimensionales
contour() Gráficos de contornos
contourplot() Gráficos de contornos
cut() Discretiza un vector
densityplot() Gráfico de densidad condicional
dotchart() Gráfico de puntos
dotplot() Gráfico de puntos
floor() Redondea al mayor entero menor
hist() Histograma
histogram() Histograma
image() Gráficos de niveles
label.var() Etiqueta una variable
levelplot() Gráficos de niveles
max() Calcula el máximo
pairs() Gráficos de matrices
parallel() Gráficos paralelos
paste() Forma una cadena con subcadenas
persp() Gráficos tridimensionales
plot() Gráfico de nubes de puntos
qqmath() Gráfico quantil-quantil teóricos
qq() Gráfico quantil-quantil reales
qqnorm() Gráfico quantil-quantil teóricos
qqplot() Gráfico quantil-quantil reales
rowSums() Suma las filas de una tabla o matriz
splom() Gráficos de matrices
stripchart() Gráfico de puntos de una dimensión
stripplot() Gráfico de puntos de una dimensión
table() Crea una tabla
use() Crea un data frame oculto en memoria
xyplot() Gráfico de nubes de puntos
wireframe() Gráficos tridimensionales

Función Acción
ellipse Dibujar elipses con ellipse package [218]
lattice Gráficos ((Trellis)) con lattice package [189]
latticeExtra Gráficos ((Trellis)) con latticeExtra package [219]
mapproj Proyección de mapas con mapproj package [220]
PROBLEMAS
Problema 1. Represente un gráfico de densidad de la fuerza máxima para cada uno
de los años de edad en los varones.
Problema 2. Represente el mapa de la Comunidad de Cantabria.
Problema 3. Dibuje la matriz de correlaciones de las variables numéricas de la BdD
de laFuerza en adolescentes.
Problema 4. Con volcano presente en el paquete datasets, ¿cómo puede con-
seguir esta imagen?

www.editorialuc.es
Capı́tulo 22
Gráficos ggplot2
Los gráficos ((ggplot2)) fueron creados por Hadley Wickham en 2009 [221,
222]. Desde entonces han ido siendo aceptados por la comunidad cientı́fica po-
co a poco y actualmente son empleados con profusión [188, 210, 223, 224]. El
creador de esta librerı́a, uno de los más prolı́ficos autores de paquetes para R,
se basó en los conceptos de Wilkinson [225] publicados en su libro ((Grammar of
Graphics)) en el que se pueden juntar de alguna manera diferentes componen-
tes.
22.1. Estructura de los gráficos

Este tipo de gráficos tiene varios componentes:
data set. Es el data frame que proporciona los datos para el gráfico.
aes. La aesthetic es la asignación de variables a las abscisas y ordenadas.
geoms. Son un conjunto de marcas visuales que representan los puntos
coord. Es el sistema de coordenadas que se emplea en el gráfico; por

defecto son las coordenadas cartesianas, pero admite transformaciones,
cambio de x por y, coordenadas polares y diferentes coordenadas geográfi-
cas para visualización de mapas.
stats. Son transformaciones estadı́sticas de los datos para conseguir los

valores necesarios para producir un geom, por ejemplo, los distintos blo-
ques para un histograma, los cinco números para un boxplot, etc.
facets. Permite crear el mismo gráfico en subconjuntos de datos.
labels. Para poder poner etiquetas en los ejes cartesianos y en el tı́tulo del
gráfico.
legend. Para añadir leyendas.
theme. Para controlar el fondo gris, blanco, con sin cuadrı́cula, etc.
scale. Permite controlar tamaños, puntos, etc.
271
272 CAPÍTULO 22. GRÁFICOS GGPLOT2
La orden básica es:
ggplot(data=xxx, aes(), geom())
Las posibilidades del componente geom son muy amplias, como se recoge
en la Tabla 22.1.
Tabla 22.1: Diferentes geoms según el tipo de variables empleadas y otras.
Variable Tipo Geom

Una discreta geom bar()
continua geom histogram()
geom dotplot()
geom density()
geom area()
geom freqpoly()
Dos X discreta, Y discreta geom jitter()

X discreta, Y continua geom bar()
geom boxplot()
geom dotplot()
geom violin()
X continua, Y continua geom smooth()
geom quantile()
geom jitter()
geom blank()
geom point()
geom rug()
geom text()
Visualizar errores geom crossbar()
geom linerange()
geom pointrange()
geom errorbar()
Mapas geom map()
Tres X, Y, Z geom contour()

geom raster()
geom tile()
Otras geom polygon()

geom path()
geom ribbon()
geom segment()
geom rect()
No queremos abrumar al lector con todas las posibilidades del paquete

ggplot2 que, como ya hemos dicho, son amplı́simas y que el lector debe ir
explorando consultando la bibliografı́a referida al inicio del capı́tulo y el libro
de Chang [226]. Además, siguen apareciendo nuevos paquetes que enriquecen
más este sistema gráfico (ver Tabla 22.2).

Tabla 22.2: Paquetes que amplı́an las posibilidades de ggplot2.
www.editorialuc.es
Paquete Descripción
GGally Extension to ”ggplot2”
ggalt Extra coordinate systems, geoms and statistical transforma-
tions for ”ggplot2”
ggbeeswarm Categorical scatter (violin point) plots
ggcorrplot Visualization of a correlation matrix using ”ggplot2”
ggdendro Create dendrograms and tree diagrams using ”ggplot2”
ggExtra Add marginal histograms to ”ggplot2”, and more ”ggplot2”
enhancements
ggfortify Data visualization tools for statistical analysis results
ggiraph Make ”ggplot2”graphics interactive using ”htmlwidgets”
ggmap Spatial visualization with ggplot2
ggmcmc Tools for analyzing MCMC simulations from bayesian infe-
rence
ggnetwork Geometries to plot networks with ”ggplot2”
ggparallel Variations of parallel coordinate plots for categorical data
ggplot2 An implementation of the grammar of graphics
ggplot2movies Movies data
ggpmisc Miscellaneous extensions to ”ggplot2”
ggRandomForests Visually exploring random forests
ggraptR Allows interactive visualization of data through a web brow-
ser GUI
ggrepel Repulsive text and label geoms for ”ggplot2”
ggROC Package for roc curve plot with ggplot2
ggsci Scientific journal and sci-Fi themed color palettes for ”gg-
plot2”
ggseas ”stats”for seasonal adjustment on the fly with ”ggplot2”
ggsn North symbols and scale bars for maps created with ”ggplot2”
or ”ggmap”
ggspectra Extensions to ”ggplot2”for radiation spectra
ggswissmaps Offers various swiss maps as ggplot2 objects
ggtern An extension to ”ggplot2”, for the creation of ternary dia-
grams
ggThemeAssist Add-in to customize ”ggplot2”themes
ggthemes Extra themes, scales and geoms for ”ggplot2”
ggvis Interactive grammar of graphic
22.2. Gráficos de ejemplo

Comprenderemos mejor su ((filosofı́a)) mediante ejemplos prácticos.
22.2.1. Nubes de puntos

Se recogieron datos antropométricos y dinamométricos de una muestra am-
plia de adolescentes de 12 a 17 años de edad en varios centros educativos de
Cantabria. Suponga que se desea representar la fuerza manual de los adoles-
centes en función de su edad.
Con los gráficos clásicos se consigue la Figura 22.1.

Figura 22.1: Fuerza máxima (kgf) en adolescentes.
Edad y Fuerza máxima en los adolescentes
Se aprecia un comportamiento diferente de la fuerza en función del sexo

(rojo = femenino y azul = masculino), por lo que se puede mejorar añadiendo
una lı́nea de regresión no paramétrica para cada sexo utilizando la función
scatterplot() del paquete car (Figura 22.2).
sexo
● Femenino Masculino
50
40
fmax
● ●
●
●● ●
30
● ● ●● ●●
● ● ● ● ●●●● ●●
● ●
●●● ● ● ●● ● ● ●● ●●
● ●● ●●●
●
●● ●● ●● ●●● ●● ● ● ● ● ● ●●●●●●● ●●●●●
● ●● ● ●●●●●●●●● ●● ●●●●●●● ●● ●●● ●●●
●●●●
● ●●●●●
●
● ●●● ● ● ●●
● ● ●● ● ● ●●● ●● ● ● ●
● ●● ● ●●●
●● ● ●
20
●
● ● ● ● ●● ● ●
●● ● ● ● ● ●
●●●● ●● ● ●● ● ● ●
●●
● ● ●
● ● ●● ● ●●●●●
●
● ●
●●
●● ●
●
13 14 15 16 17 18
edad
Pero con el paquete ggplot2 se obtiene un gráfico más elegante e ilustra-

tivo (Figura 22.3).
Aquı́ los puntos están coloreados en función del sexo, y se han dibujado las
dos lı́neas de regresión suavizada con su intervalo de confianza del 95 %.
El código empleado para obtener esta figura es el siguiente:
> g1 <- ggplot(.data, aes(x = edad, y = fmax, colour = sexo)) +

+ geom_point() +
+ scale_color_brewer(palette = ’Set1’) +
+ ggtitle(’Edad y Fuerza máxima en los adolescentes’)
> g1 + geom_smooth()

www.editorialuc.es
●
●
50 ● ●
●
● ● ●
● ● ● ● ●
● ● ●
● ●
● ● ● ●
● ●● ● ●
● ● ●
● ● ● ●●
● ●
● ●
● ● ● ● ● ●●
40 ●
● ● ●
●
●
● ●
●
● sexo
● ● ●● ●● ●
fmax
●
● ●
●
● ●● ● ● ● ●●
●
●●
● ● ● ● ●
●● ● ● ● ● Femenino
●●
● ● ● ●●● ●●
● ●● ●
● ● ● ● ● ● ● ● ● ●●
●● ● ● ● ● ● ●
●● ●●
● ●● ● ● Masculino
● ●● ●● ● ●
30 ● ● ● ●
●● ● ● ● ● ●● ● ●
● ● ● ●● ●
● ●
●● ● ●
● ● ●● ● ●
●●● ● ● ● ● ● ● ●●●● ●
● ● ● ●●
● ● ● ● ●
● ● ●● ● ●● ●● ● ●● ●● ●● ● ● ● ●● ● ●● ●● ●
●● ● ● ● ● ●● ● ●
● ● ● ●●● ●● ●●●
● ●● ●●● ●● ● ● ●● ●● ● ● ●●●● ●● ● ●● ● ● ● ●●
● ● ● ●● ● ●● ● ● ● ●●● ●●● ●● ●●● ● ● ●●
● ●●● ● ● ●● ●● ● ● ● ● ● ●● ●
● ●● ● ● ●● ●● ● ● ●●
●●
●● ●●●●●● ●●
●●
●
●
● ● ● ● ● ●
●
●● ●
●●
●●
●●
●● ●● ●● ●● ●● ●● ● ●● ● ● ● ●
● ●●
●● ● ● ●●
20 ● ●
●●● ●● ● ●● ● ● ● ● ●● ●
●
● ●
●●●
●
● ● ● ● ● ● ●●●
●● ● ● ●●
●
●● ● ● ●
●
●
●
●● ●
10
14 16 18
edad
La función ggplot() crea el gráfico y lo asigna al objeto g1. En esta fun-

ción: (1) primero se pone el nombre del objeto donde están los datos, en este
caso la BdD se llama .data; (2) en segundo lugar se declara la estética con
la función aes(), es decir qué variable irá en el eje de las abscisas y cuál
en de las ordenadas; (3) después se declara la paleta de color con la función
scale color brewer(); finalmente, (4) se declara el tı́tulo del gráfico con la
función ggtitle(). Al asignar el gráfico a un objeto no se imprime, por lo
que si lo queremos ver tendemos que teclear g1 y aparecerı́a la Figura 22.4
g1
Figura 22.4: Fuerza máxima (kgf) en adolescentes. Nube de puntos.

●
●
50 ● ●
●
● ● ●
● ● ● ● ●
● ● ●
● ●
● ● ● ●
● ●● ● ●
● ● ●
● ● ● ●●
● ● ● ● ●
● ● ● ● ●● ●
40 ●
● ● ●
●
● ●
●
● sexo
● ● ●● ●● ●
fmax
●
● ●
●
● ●● ● ● ● ●●
●
●●
● ● ● ● ●
●●
● ● ● ●●● ●●
● ●● ●
● ● ● ● ● ● ● ● ● ●●
●● ● ● ● ● ● ●
●● ● ●● ●● ● ● Masculino
● ●● ●● ●
30 ●● ● ● ● ●● ●● ●
● ● ● ● ● ●● ●
●
●● ● ● ●● ● ●
● ● ●●●● ● ● ●● ●
● ●
● ● ●
● ● ●● ● ● ● ● ● ● ●●
● ● ●● ● ●● ●● ● ●● ●● ●● ● ● ● ● ●● ●
●● ● ● ● ● ●● ● ●● ● ● ●● ● ●● ● ●●● ●● ●●●
● ●● ●●● ●● ● ● ●● ●● ● ● ●●●● ●● ● ●● ● ● ● ●●
● ● ● ●● ● ●● ● ● ● ●●● ●●● ●● ●●● ● ● ●●
● ●●● ● ● ●● ●● ● ● ● ● ● ●● ●
● ●● ● ● ●● ●● ● ● ●●
●
●● ●●●●●
● ● ●●
●●
●
●
● ● ● ● ● ●
●
●● ●
●●
● ●
●●● ● ● ●● ●● ● ●● ● ●
●● ● ● ●●● ● ● ●● ●● ● ● ●●
20 ●● ● ● ●●
● ●● ● ● ● ● ● ●●
● ●
●●●● ● ● ● ● ● ● ● ●●●
●● ● ● ●●
●
●● ● ● ●
●
●
●
●● ●
10
14 16 18
edad
Pero este gráfico no interesa ya que es mucho mejor el que presenta las
lı́neas de regresión, con su intervalo de confianza, para cada uno de los sexos
(Figura 22.3). Lo interesante de ggplot2 es que como va creando los gráficos
por capas, ahora simplemente hay que añadir a g1 la orden para que dibuje las
lı́neas de regresión utilizando la función geom smooth().

g1 + geom_smooth()
Igualmente, si en vez de estas curvas de regresión no paramétrica nos in-

teresara más dibujar las rectas de regresión lineal (Figura 22.5), añadirı́amos al
objeto g1 el siguiente código:
> g1+ geom_smooth(method = lm)
Figura 22.5: Fuerza máxima (kgf) en adolescentes. Nube de puntos y rectas de regre-
sión lineal simple según sexo.

●
●
50 ● ●
●
● ● ●
● ● ● ● ●
● ● ●
● ●
● ● ● ●
● ●● ● ●
● ● ●
● ● ● ●●
● ●
● ●
● ● ●● ●
●● ●
40 ●
● ● ●
● ●
● ●
●●●
● sexo
● ●● ●
fmax
●
● ● ●
● ●● ● ● ● ●●
● ●
●●
● ●● ●
●● ●● ● ●
●
● ●● ●
● ●● ●●
●●
●
● ● ● ● ● ●
●● ● ● ● ● ● ●
●● ●●
● ●● ● ● Masculino
● ●● ●● ●
30 ●● ● ● ● ●● ●● ●
● ● ● ● ● ●● ●
●
●● ● ● ● ●● ● ●
● ● ●●● ● ● ● ●
● ● ● ●●
● ●
● ●
● ● ● ● ●●●● ●
● ● ●● ● ●● ●● ● ●● ●● ●● ● ● ● ● ●● ●
●● ● ● ● ● ●● ● ●● ● ● ●● ● ●● ● ● ●●●● ●●●
● ●● ●●● ●● ● ● ●● ● ● ●
● ●
●● ● ● ●●● ● ● ●
● ●●
● ● ● ●● ● ●● ●● ● ● ●● ● ●●● ●● ●●● ● ●●
● ●●● ● ● ●● ●● ● ● ● ● ● ●● ●
● ● ●● ● ●
● ●● ●● ● ● ●●
● ●
● ● ● ●
●●
●● ● ● ●● ● ● ● ● ● ● ● ●● ●
●●
●●
●●
●● ●
● ●● ●● ●● ●● ● ●● ● ● ● ●
● ●●
●● ● ● ●●
20 ● ●
●●● ● ●● ●● ● ● ● ● ●●● ●
● ●
●●●
●
● ● ● ● ● ● ●●●
●● ● ● ●●
●
●
●● ● ●
●
●
●
●● ●
10
14 16 18
edad
Se aprecia claramente el diferente comportamiento de los sexos en cuanto

a la fuerza: en las chicas prácticamente se mantiene constante y en los chicos
aumenta con la edad.
Se pueden cambiar otros aspectos del gráfico, por ejemplo la forma de los
puntos con el parámetro shape y/o con la función scale shape manual(),
como vemos a continuación.
Ejemplo 22.1. Represente gráficamente la fuerza máxima (kgf) con curvas

de regresión suavizada y con puntos redondos y rojos para las chicas y cua-
draditos azules para los chicos.
> g2 <- ggplot(.data, aes(x = edad, y = fmax,

+ colour = sexo, shape = sexo)) +
+ geom_point() +
+ scale_color_brewer(palette = ’Set1’) +
+ ggtitle(’Edad y Fuerza máxima en los adolescentes’)
> g2 <- g2 + scale_shape_manual(values=c(16, 15))
> g2 + geom_smooth()
> g2 + labs(x = ’Edad (años)’, y = ’Fuerza máxima (kgf)’)

Figura 22.6: Fuerza máxima (kgf) en adolescentes. Nube de puntos y curvas de regre-
sión no paramétrica según sexo.
www.editorialuc.es
50
Fuerza máxima (kgf)
40
sexo
●
● Femenino
●
● ●
●●
● ●
●● Masculino
30 ● ● ● ●
●●
●
● ● ● ●● ●●
● ●
● ● ●
● ● ● ●●● ●
● ● ● ●● ● ● ● ●● ●
●● ● ● ● ● ● ●● ●●
● ● ● ● ● ●● ●●●
● ● ● ● ● ●● ● ●● ●
●
●●
● ● ●● ●● ●● ● ● ● ●●● ● ● ●●● ● ●● ●
● ●● ● ● ●● ● ● ● ● ● ●
● ●
● ●● ●●
● ●● ● ● ● ●
●●
●
● ●● ●● ● ● ● ●● ●
●
●● ● ●● ● ●● ● ●● ● ● ● ●
●● ● ●
20 ●● ●
●● ● ● ● ●
●
●
●
● ●● ●
● ● ●●● ● ●●● ● ● ●●●
● ● ●
●●
●
10
14 16 18
Edad (años)
Como se puede ver en la Figura 22.6 ahora las etiquetas de ambos ejes están
correctamente rotuladas.
En otras ocasiones interesa un gráfico de nube de puntos con los puntos co-
loreados según un gradiente de color correspondiente a una variable numérica.
Ejemplo 22.2. Represente gráficamente la fuerza máxima de los varones

según la edad y coloreada según su IMC.
> ggplot(z,
+ aes(x=edad, y=fmax, fill=imc)) +
+ geom_point(shape=21, size=2.5) +
+ scale_fill_gradient(low=’green’, high = ’red’)
22.2.2. Histogramas y curvas de densidad

Cuando se quiere representar gráficamente una variable numérica continua
un histograma es uno de los gráficos indicados. Con ggplot2 se va constru-
yendo el histograma en capas.
Ejemplo 22.3. Construya un histograma clásico con la variable fmax.
> hist(fmax, breaks=20)
Ejemplo 22.4. Construya un histograma mejorado con la variable fmax.

Figura 22.7: Fuerza máxima (kgf) en adolescentes. Nube de puntos coloreados según
el IMC de los sujetos (verde = menor y rojo = mayor).
Figura 22.8: Histograma de la fuerza máxima (kgf) en adolescentes.
Histogram of fmax
60
Frequency
40
20
0
20 30 40 50
fmax

> ggplot(.data, aes(x = fmax)) +

+ geom_histogram(binwidth = 2,
www.editorialuc.es
+ fill = ’orange’, colour = ’black’) +
+ labs(x = ’Fuerza máxima (kgf)’, y = ’Frecuencia’)
Figura 22.9: Histograma de la fuerza máxima (kgf) en adolescentes.
60
Frecuencia
40
20
10 20 30 40 50
En ocasiones interesa un histograma por cada una de las categorı́as de una

segunda variable:
Ejemplo 22.5. Construya un histograma mejorado con la variable fmax di-

ferenciando por sexo.
Figura 22.10: Histograma de la fuerza máxima (kgf) en adolescentes según su sexo.
40
Femenino
20
Frecuencia
40
Masculino
20
0
10 20 30 40 50


+ geom_histogram(binwidth = 2,
+ fill = ’orange’, colour = ’black’) +
+ labs(x = ’Fuerza máxima (kgf)’, y = ’Frecuencia’) +
+ facet_grid(sexo ˜ .)
A veces, más que el histograma en sı́, lo que interesa es la curva de densi-

dad.
Ejemplo 22.6. Dibuje un histograma de densidad de la fuerza máxima fmax.

+ geom_density(fill = ’blue’, colour = NA, alpha = 0.2) +
+ geom_line(stat = ’density’)
Figura 22.11: Histograma de densidad de la fuerza máxima (kgf) en adolescentes.
0.06
0.04
density
0.02
0.00
10 20 30 40 50
fmax
Se pueden dibujar más de una curva de densidad en el mismo gráfico, por

ejemplo para diferenciar según los niveles de un factor. En este caso, entre los
parámetros estéticos debe estar uno de color o de relleno.
Ejemplo 22.7. Dibuje un histograma de densidad de la fuerza máxima fmax

diferenciando entre los del sexo masculino y femenino.
> ggplot(.data, aes(x = fmax, fill = sexo)) +

+ geom_density(alpha = 0.2) +
+ geom_line(stat = ’density’)
Además, se pueden dibujar curvas de densidad por un segundo factor.

Figura 22.12: Histograma de densidad de la fuerza máxima (kgf) en adolescentes según

su sexo.
www.editorialuc.es
Ejemplo 22.8. Dibuje un histograma de densidad de la fuerza máxima fmax
diferenciando entre los del sexo masculino y femenino para los sujetos dies-
tros y zurdos.
Figura 22.13: Histograma de densidad de la fuerza máxima (kgf) en adolescentes según

su sexo.
> ggplot(.data, aes(x = fmax, fill = sexo)) +

+ geom_density(alpha = 0.2) +
+ geom_line(stat = ’density’) +
+ facet_grid(md ˜ .)
En este gráfico se aprecia claramente que los zurdos tienen más fuerza que
los diestros, ya que sus curvas de densidad están ligeramente desplazadas ha-
cia la derecha.

22.2.3. Box plots

Los gráficos boxplots se utilizan para representar gráficamente variables nu-
méricas. Proporcionan una mejor comprensión de la distribución de la variable
que la puesta de manifiesto por los histogramas, por lo que se utilizan más que
estos.
Ejemplo 22.9. Representa la fmax de los adolescentes mediante un gráfico

boxplot.
> p1 <- ggplot(.data, aes(x = 1, y = fmax)) +

+ geom_boxplot() +
+ stat_summary(fun.y = ’mean’, geom = ’point’, shape = 23,
+ fill = ’orange’)
> p2 <- ggplot(.data, aes(x = sexo, y = fmax)) +
+ geom_boxplot(notch = TRUE, fill = col_sexo) +
+ stat_summary(fun.y = ’mean’, geom = ’point’, shape = 23,
+ fill = ’orange’, size = 2)
Figura 22.14: Box plot de la fuerza máxima (kgf) en adolescentes. A la izquierda de

manera global y a la derecha según su sexo.
● ●
50 ● 50
●
●
●
●
40 40
fmax
fmax
30 30
20 20
10 10
0.6 0.8 1.0 1.2 1.4 Femenino Masculino
1 sexo
Aquı́ se ha representado la fuerza máxima de manera global para todos los

adolescentes y de separadamente para cada sexo. Se aprecia que la distribución
de la fuerza máxima es diferente en las mujeres que en los hombres. En esta
Figura 22.14 se ha representado mediante un punto con forma de diamante la
media, que es diferente de la mediana (la lı́nea en el interior de las cajas); de
manera que cuánto más se alejan entre sı́, más probable es que la distribución
no siga una Ley Normal. En la Figura 22.14, lado izquierdo, la discrepancia es
del 21 %, cifra ≥ 5 %, por lo que no sigue una Ley Normnal. En el lado derecho,
la discrepancia es del 4 % para las mujeres y del 5 % para los varones.

La función Fdiscrepa mdym() solo admite como parámetro la variable

numérica que se va a comprobar.
www.editorialuc.es
#---------------------------------------------------------------
Fdiscrepa_mdym(x)
#---------------------------------------------------------------
Su código es muy sencillo:
> #-----------------------------------------------------------
> # Fdiscrepa_mdym() Discrepancia entre mediana y media
> #-----------------------------------------------------------
> Fdiscrepa_mdym <- function(x, dec = 3) {
+ if (!is.numeric(x)) stop(’x must be a numeric variable’)
+ x <- x[!is.na(x)]
+ md <- median(x)
+ m <- mean(x)
+ iqr <- IQR(x)
+ cn <- abs(md - m) / iqr
+ normalidad = ifelse(cn < 0.05, ’Normal’, ’no normal’)
+ res <- list(shapiro_wilk = shapiro.test(x),
+ statistics = c(mean = m, median = md, IQR = iqr,
+ discr = round(cn, dec)),
+ signif = normalidad)
+ res
+ }
> #----------------------------------------fin Fdiscrepa_mdym()
En ocasiones se pretende describir un variable en función de otra creando

distintos gráficos boxplot según niveles de una segunda variable. Esto se consi-
gue en ggplot2 con facets.
Ejemplo 22.10. Grafique mediante boxplot la evolución de la fuerza máxima

de los adolescentes según la edad y el sexo.
> ggplot(.data, aes(x = factor(floor(edad)), y = fmax)) +

+ geom_boxplot(fill = rep(col_sexo, c(6, 6))) +
+ facet_grid(. ˜ sexo)
Se aprecia el diferente comportamiento de la fuerza y la edad según el sexo.

En algunas ocasiones no interesa el color del fondo. Se puede controlar con
theme().
Ejemplo 22.11. Repita el ejemplo anterior sin el color del fondo.
> ggplot(.data, aes(x = factor(floor(edad)), y = fmax)) +

+ geom_boxplot(fill = rep(col_sexo, c(6, 6))) +
+ facet_grid(. ˜ sexo) +
+ theme_bw()
22.2.4. Curvas y otras funciones

Dibujar curvas con ggplot2 es sencillo: se debe usar la función stat function()
a la que se le pasa un data frame ficticio para controlar el rango de la variable.

Figura 22.15: Box plot de la fuerza máxima (kgf) en adolescentes según su edad en
años cumplidos. A la izquierda en chicas y a la derecha en chicos.
Femenino Masculino
50
●
40
fmax
● ● ●
●
●
●
30
20
●
●
10
12 13 14 15 16 17 12 13 14 15 16 17
factor(floor(edad))
Figura 22.16: Box plot de la fuerza máxima (kgf) en adolescentes según su edad en
años cumplidos. A la izquierda en chicas y a la derecha en chicos.
Femenino Masculino
50
●
40
fmax
● ● ●
●
●
●
30
20
●
●
10
12 13 14 15 16 17 12 13 14 15 16 17
factor(floor(edad))

Ejemplo 22.12. Dibuje dos figuras: a la izquierda la curva normal estandari-

zada en un rango de -4 a +4 y a la derecha una curva ji cuadrado en un rango
www.editorialuc.es
de 0 a 20 con df = 5.
> p1 <- ggplot(data.frame(x = c(-4, 4)), aes(x = x)) +

+ stat_function(fun = dnorm) +
+ labs(x = ’z’, y = ’f(x)’)
>
> p2 <- ggplot(data.frame(x = c(0, 20)), aes(x = x)) +
+ stat_function(fun = dchisq, args = list(df = 5))
Figura 22.17: Curva normal estandarizada.

0.4
0.15
0.3
0.10
f(x)
0.2
y
0.05
0.1
0.0 0.00
−4 −2 0 2 4 0 5 10 15 20
z x
Ejemplo 22.13. Dibuje las siguientes curvas:

√
f (x) = x x + 3
10x
f (x) =
x2 + x + 2
> myfun <- function(x) x * sqrt(x + 3)

> myfun2 <- function(x) 10 * x / (x ˆ 2 + x + 2)
> ggplot(data.frame(x = c(-3, 2)), aes(x = x)) +
+ stat_function(fun = myfun, n = 200, lwd = 1.2, col = 2) +
+ stat_function(fun = myfun2)
Podemos sombrear el área bajo la curva entre unos lı́mites determinados:
Ejemplo 22.14. Se quiere sombrear el área entre -0.5 y 1.6 de la curva normal
estandarizada.
> FlimitRange <- function(fun, min, max) {

+ function(x) {
+ y <- fun(x)
+ y[x < min | x > max] <- NA

Figura 22.18: Curva normal estandarizada.
2.5
0.0
y
−2.5
−5.0
−3 −2 −1 0 1 2
x
Figura 22.19: Área bajo la curva normal estandarizada.

0.4
0.3
0.2
y
0.1
0.0
−2 0 2
x

+ y
+ }
www.editorialuc.es
+ }
>
> dlimit <- limitRange(dnorm, -0.5, 1.6)
> ggplot(data.frame(x = c(-3, 3)), aes(x = x)) +
+ stat_function(fun = dnorm) +
+ stat_function(fun = dlimit,
+ geom = ’area’, fill = ’blue’, alpha = .3) +
+ theme_bw()
22.2.5. Gráfico de barras

Los gráficos de barras se emplean en la descripción de variables cualitati-
vas.
Ejemplo 22.15. Cree un gráfico de barras con los alumnos en cada centro.
> ggplot(data = .data, aes(x = ies)) +

+ geom_bar(fill = c(’turquoise’, ’sienna2’, ’orchid1’)) +
+ theme_bw()
Figura 22.20: Distribución de los alumnos estudiados en cada uno de los centros edu-
cativos.
150
100
count
50
IES−A IES−B IES−C

ies
También se puede controlar por una segunda variable cualitativa con facet().
Ejemplo 22.16. Cree un gráfico de barras de la distribución de los alumnos

según sexo en cada curso.

> ggplot(data = .data, aes(x = sexo)) +

+ geom_bar(fill = rep(col_sexo, 5), colour = ’black’) +
+ facet_grid(. ˜ curso)
Figura 22.21: Distribución de los alumnos estudiados en cada uno de los centros edu-
cativos.
1º Bach 1º ESO 2º ESO 3º ESO 4º ESO
60
40
count
20
Femenino Masculino Femenino Masculino Femenino Masculino Femenino Masculino Femenino Masculino
sexo
22.2.6. Matriz de correlaciones

Las matrices de correlaciones son difı́ciles de interpretar si hay muchas y
tienen muchos decimales. Para resolver esto ayuda muchı́simo una buena re-
presentación gráfica de dichas matrices.

talla, fmd, fmi, fmax e imc y grafı́quelas.
> require(ggcorrplot)
> corr <- cor(.data[, c(3, 8:13)])
> corrp <- cor_pmat(.data[, c(3, 8:13)])
> round(corr, 2)
edad peso talla fmd fmi fmax imc
edad 1.00 0.42 0.52 0.39 0.40 0.41 0.19
peso 0.42 1.00 0.67 0.58 0.58 0.59 0.83
talla 0.52 0.67 1.00 0.66 0.66 0.67 0.16
fmd 0.39 0.58 0.66 1.00 0.93 0.99 0.27
fmi 0.40 0.58 0.66 0.93 1.00 0.96 0.27
fmax 0.41 0.59 0.67 0.99 0.96 1.00 0.28
imc 0.19 0.83 0.16 0.27 0.27 0.28 1.00
> ggcorrplot(corr, method = ’circle’)
Visualmente se aprecia que la fuerza máxima se correlaciona positivamente

con la fuerza de la mano derecha e izquierda (como era de esperar) y que el
IMC se correlaciona con el peso y mucho menos con la talla.
Por supuesto, en vez de cı́rculos se podı́a haber puesto cuadrados de colores
y sobreimpreso en cada uno de ellos el coeficiente de correlación r.


son edad, peso, talla, fmd, fmi, fmax, imc.
www.editorialuc.es
imc ● ● ● ● ●
fmax ● ● ● ●
Corr
fmi ● ● ● ● 1.0
0.5
fmd ● ● ● ● 0.0
talla ● ● ● ● ● ●
−0.5
−1.0
peso ● ● ● ● ●
edad ● ● ● ● ● ●
d
so
lla
ax
c
fm
im
a
fm
ta
pe
fm
ed

talla, fmd, fmi, fmax e imc. y dibuje la matriz inferior en colores y con el
coeficiente r.

son edad, peso, talla, fmd, fmi, fmax, imc..
fmd 0.99
fmi 0.93 0.96

Corr
1.0
talla 0.66 0.66 0.67 0.5
0.0
edad 0.52 0.4 0.39 0.41
−0.5
−1.0
imc 0.19 0.16 0.27 0.27 0.28
peso 0.83 0.42 0.67 0.58 0.58 0.59

c
ad
lla
ax
fm
im
fm
ta
fm
ed
> ggcorrplot(corr, hc.order = TRUE, type = "lower",

+ lab = TRUE)
22.2.7. Mapas
En estudios epidemiológicos, en ocasiones es importante presentar mapas.
Con ggplot2 se puede realizar esta tarea. A modo de ejemplo se presenta el

mapa de las comarcas de Cantabria con datos ficticios del número de lectores
de una determinada publicación (Figura 22.24).
Figura 22.24: Mapa de Cantabria con datos ficticios de incidencia de una enfermedad
determinada.
smier
> library(rgdal)
> # Datos administrativos de GADM y selecciono Cantabria
> load("/Users/carlosredondofiguero/Downloads/ESP_adm3.RData")
> cant3.spdf <- gadm[gadm$NAME_2 == "Cantabria", ]
> cant3.df <- fortify(cant3.spdf, group = "NAME_2")
> set.seed(2015)
> # Genero datos epidemiológicos de forma aleatoria para cada id
> epidem.df <- data.frame(id = unique(cant3.df[ ,’id’]),
+ epidem = rpois(11, 450),
+ min = 0, max = 2000)
> #epidem = runif(n = length(unique(cant3.df[ ,’id’])),
>
> # Fusiono ambos data.frames
> cant3.df <- merge(cant3.df, epidem.df,
+ by.y = ’id’, all.x = TRUE)
> # Obtengo las coordenadas para las etiquetas
> cant3.centroids.df <- data.frame(
+ long = coordinates(cant3.spdf)[, 1],
+ lat = coordinates(cant3.spdf)[, 2],
+ ID_2 = cant3.spdf@data[, "ID_3"],
+ NAME_2 = cant3.spdf@data[, ’NAME_3’])
> #Cambio codificación del texto de latin a utf-8 para que se muestren
los acentos correctamente
> cant3.centroids.df$NAME_2 <- as.factor(

+ iconv(as.character(cant3.centroids.df$NAME_2),
+ "latin1", "utf-8"))
www.editorialuc.es
> # Create ggplot with labels for administrative areas
> require(ggplot2)
> ggplot(cant3.df, aes(x = long, y = lat, group = group)) +
+ geom_polygon(aes(fill = cut(epidem,11))) +
+ geom_text(data = cant3.centroids.df,
+ aes(label = NAME_2, x = long, y = lat,
+ group = NAME_2), size = 3) +
+ labs(x=" ", y=" ") +
+ scale_fill_brewer(’Incidencia’,
+ palette = ’Accent’) +
+ coord_map() +
+ theme(axis.ticks = element_blank(),
+ axis.text.x = element_blank(),
+ axis.text.y = element_blank()) +
+ theme(panel.border = element_blank())

tablas:
Función Acción
abs() Valor absoluto
aes() Estética de un gráfico ggplot
cor() Correlación entre variables numéricas
cor pmat() Matriz de significación de una matriz de correla-
ciones
ifelse() Ejecución condicional vectorizada
facet grid() Rejilla de gráficos condicionales
Fdiscrepa mdym() Diferencia entre mediana y media
FlimitRange() Limita el rango para área bajo la curva
floor() Redondea hacia abajo
geom bar() Gráfico de barras
geom boxplot() Gráfico boxplot
geom density() Gráfico de densidad
geom histogram() Histograma
geom line() Lı́nea
geom point() Punto/s
geom smooth() Ajuste suavizado
ggcorrplot() Gráfico de una matriz de correlaciones
ggplot() Principal función del paquete ggplot2
ggtitle() Pone tı́tulo al gráfico
hist() Histograma clásico
IQR() Rango intercuartı́lico
mean() Media

Función Acción
labs() Pone etiquetas al gráfico
median() Mediana
rep() Repite elementos de un vector
round() Redondea a un número fijo de decimales
scale color brewer() Escala de color
scale fill gradient() Escala de relleno
scale shape manual() Escala manual
scatterplot() Nube de puntos (paquete car)
shapiro.test() Prueba de Shapiro-Wilk
stat function() Estadı́stica para una función
stat summary() Estadı́stica para boxplot
theme bw() Fondo en blanco y negro
Función Acción
car Funciones con car package [120]
ggcorrplot Matriz de correlaciones con ggcorrplot package [227]
ggplot2 Gráficos elegantes con ggplot2 package [221]
rgdal Paquete para datos geoespaciales rgdal [228–230]
PROBLEMAS
Problema 1. Con la BdD de las indias Pima, dibuje la recta de regresión lineal simple
y sus bandas de confianza para el modelo de la TAD en función de la edad.
Problema 2. Dibuje la matriz de correlaciones de las variables numéricas de la BdD
de las indias Pima empleando la función adecuada correspondiente al sistema gráfico
ggplot2.
Problema 3. Represente en un histograma la TAD de las indias Pima, diferenciando
entre diabéticas y no diabéticas.
Problema 4. Dibuje los box plots del IMC de las indias Pima según su estado nutri-
cional.
Problema 5. Represente mediante un gráfico de nube de puntos las variables
height waist de la BdD correspondiente a las Familias. Coloree los puntos co-
rrespondientes a cada familia con un color diferente y dibuje la recta suavizada de
regresión no paramétrica con su intervalo de confianza.

www.editorialuc.es
Parte IV
PROGRAMACIÓN

www.editorialuc.es
Capı́tulo 23
Scripts
23.1. Concepto
Un script es un fichero de texto con las instrucciones que debe ejecutar el
procesador secuencialmente1 .
Los comandos u órdenes se pueden teclear directamente en la consola; tras
pulsar ((Intro)) aparece el resultado en la misma. Este proceso se llama estilo
interactivo [231] y puede ser útil en contadas ocasiones, por ejemplo cuando se
hace una operación sencilla en la que se emplean pocos comandos.
Cuando hay muchos comandos, ejecuciones condicionales, etc. es mucho
mejor escribirlas en un fichero de texto que se pueda ejecutar secuencialmente,
ya que ofrece una serie de ventajas (Tabla 23.1).
Tabla 23.1: Ventajas de utilizar scripts en el trabajo con R (modificado de [231]).
# Ventajas
1 Es una manera efectiva de salvar el trabajo.
2 Permite volver atrás cuando hay un error.
3 Permite incluir notas para documentar el trabajo.
4 Permite reutilizar el código para problemas similares.
5 Permite hacer tareas complejas.
6 Permite difundir nuestro trabajo a otras personas.
23.2. Manejo de scripts

Para ir explicando el manejo de los scripts vamos a programar cómo resol-
ver una ecuación de segundo grado.
1 De Wikipedia: ((programs written for a special run-time environment that automate[1] the execution
of tasks that could alternatively be executed one-by-one by a human operator))
295
296 CAPÍTULO 23. SCRIPTS
23.2.1. Escritura
Para escribir un script conviene utilizar un programa que permita grabar
texto plano. La mejor forma es con RStudio (Figura 23.1).
Figura 23.1: Escritura del script con RStudio .
Conviene que los scripts tengan una cabecera y que estén documentados.
Se deberá seguir estrictamente la guı́a de estilo que vimos en el capı́tulo 7. A
continuación se presenta el código del script de ejemplo:
> #-----------------------------------------------------------
> # Fecu_2g() Ecuación de segundo grado (Axˆ2 + Bx + C = 0)
> #-----------------------------------------------------------
> Fecu_2g <- function(
+ A, # coeficiente de x2
+ B, # coeficiente de x
+ C, # término independiente en Axˆ2 + Bx + C = 0
+ info = FALSE, # si se desea información extra
+ graph = TRUE, # si se desea un gráfico
+ x_inf = -20, # lı́mite inferior del eje x
+ x_sup = +20, # lı́mite superior del eje x
+ dec = 3, # decimales de redondeo
+ ... # por si se quieren pasar más parámetros
+ ) {
+ # ecuación con signos correctos
+ signo1 <- ifelse(B < 0, paste(’-’, abs(B)), paste(’+’, B))
+ signo2 <- ifelse(C < 0, paste(’-’, abs(C)), paste(’+’, C))

23.2. MANEJO DE SCRIPTS 297
+ coef2 <- ifelse(A == 1, ’’, ifelse(A == -1, ’-’, A))

+ signo1 <- ifelse(signo1 == ’+ 1’, ’+’,
www.editorialuc.es
+ ifelse(signo1 == ’- 1’, ’-’, signo1))
+ ecu <- paste(coef2, ’x?’, signo1, ’x’, signo2)
+
+ # vértice de la parábola
+ ver <- c(-B / (2 * A), -(B ˆ 2 - 4 * A * C) / (4 * A))
+
+ # semiparámetro, alfa y beta
+ p <- 1 / (2 * A)
+ alfa <- - B / (2 * A)
+ beta <- (4 * A * C - B ˆ 2) / (4 * A)
+
+ # discriminante en forma compleja (si es necesario)
+ dis <- B ˆ 2 - 4 * A * C
+ if (dis < 0) {
+ A <- A + 0i
+ B <- B + 0i
+ C <- C + 0i
+ }
+ dis <- B ˆ 2 - 4 * A * C
+
+ # soluciones de la ecuación
+ x1 <- (-B - sqrt(dis)) / (2 * A)
+ x2 <- (-B + sqrt(dis)) / (2 * A)
+ res <- c(x1 = x1, x2 = x2)
+
+ # información más amplia
+ if (info) {
+ cat(’\nSOLUCIONES DE LA ECUACIÓN DE 2o GRADO’)
+ cat(’\n=====================================’)
+ cat(’\nEcuación.....:’, ecu)
+ cat(’\n’)
+ cat(’\nSoluciones x1:’, round(x1, dec))
+ cat(’\n x2:’, round(x2, dec))
+ cat(’\n’)
+ cat(’\nSemiparámetro:’, round(p, dec))
+ cat(’\nVértice......:’, paste(’(’, round(ver[1], dec),
+ ’, ’, round(ver[2], dec),
+ ’)’, sep = ’’))
+ cat(’\nFoco.........:’, paste(’(’, round(alfa, dec), ’, ’,
+ round(beta + p / 2, dec),
+ ’)’, sep = ’’))
+ cat(’\n’)
+ cat(’\n’)
+ }
+
+ # gráfico
+ if (graph) {
+ aa <- ’Soluciones a la ecuación de 2o grado’
+ curve(A * x ˆ 2 + B * x + C,
+ from = x_inf, to = x_sup, col = 2, lwd = 2,
+ main = paste(aa, ’\n’, ecu),
+ ylab = expression(’f(x)’), ...)

+ grid()
+ abline(h = 0, col = ’grey’)
+ abline(v = 0, col = ’grey’)
+ abline(v = alfa, lt = 2, col = 5)
+ abline(h = beta - p / 2, lt = 2, col = 5)
+ points(ver[1], ver[2], col = 3, pch = 16)
+ points(alfa, beta + p / 2, pch = 15, col = 6, cex = 0.7)
+ if (!is.complex(x1) | !is.complex(x2)) {
+ points(x1, 0, col = 4, pch = 16)
+ points(x2, 0, col = 4, pch = 16)
+ }
+ }
+
+ # resultado
+ res
+
+ }
> #-----------------------------------------------fin Fecu_2g()
23.2.2. Grabación
Para grabar el script se debe pulsar en el icono que representa un disco de
ordenador. RStudio lo graba automáticamente (Figura 23.2).
Figura 23.2: Grabación del script con RStudio .
Una vez pulsado el icono de grabación, en la pestañita con el nombre del

fichero se aprecia que cambia de color y desaparece un asterisco, que es la
marca de que se han hecho cambios en el script y aún no se han guardado
(Figura 23.3).
Figura 23.3: El script se ha salvado con RStudio .
Tras pulsar ((Intro)) el icono del disco se aclara de color.

23.2. MANEJO DE SCRIPTS 299
23.2.3. Lectura
Para leer un script con RStudio se debe pulsar en el menú de RStudio
www.editorialuc.es
en el icono que representa una carpeta (Figura 23.4). Aparece una ventana y se
deberá seleccionar el fichero con el script que se desea abrir.
Figura 23.4: Apertura de un script con RStudio .
Por supuesto que también se puede hacer desde la consola con las funciones
writte() y source(), pero es mucho más cómodo con RStudio .
23.2.4. Ejecución del script

Una vez escrito se ha de ejecutar el código para comprobar que funciona
correctamente, tal y como querı́amos que lo hiciera cuando lo programamos.
Hay varias formas de ejecutar el código:
1) Ejecutar todo el script. Para ello se pulsa en el botón [Source].
2) Se marca como bloque la lı́nea o lı́neas que queramos ejecutar y después
se pulsa [Run]
3) Idem, pero luego se pulsa [ctrl] + [Intro].
Ejemplo 23.1. Vamos a escribir una lı́nea de código, la marcamos y pulsamos

[ctrl] + [Intro].
> Fecu_2g(2, 3, -2, x_inf = -3, x_sup = 1.5)

x1 x2
-2.0 0.5
Nos dice que la ecuación de segundo grado 2x2 +3x−2 tiene dos soluciones:

x1 = −2 y x2 = 0,5. Además nos hace una representación gráfica de dicho

polinomio (Figura 23.5)
Figura 23.5: Representación gráfica de la parábola 2x2 + 3x − 2.
Soluciones a la ecuación de 2º grado

2 x² + 3 x − 2
6
4
f(x)
● ●
0
−2
−3 −2 −1 0 1

tablas:
Función Acción
write() Escribe un fichero
source() Lee un fichero
PROBLEMAS
Problema 1. Escriba una función que calcule el área de un circulo, pasándole como
parámetro único la longitud de su perı́metro.

www.editorialuc.es
Capı́tulo 24
Programación de funciones
R dispone de un número importante de funciones, que son responsables

de la funcionalidad de dicho programa. Se agrupan según sus caracterı́sticas
más importantes y se estudian las de mayor utilidad en el análisis de datos
sanitarios.
Una limitación de los paquetes estadı́sticos comerciales es que ((hacen lo
que hacen)), es decir, que no dejan ir más allá de lo que su contenido permite,
por lo que, en ocasiones, cuando el usuario necesita implementar un procedi-
miento especı́fico que no existe en dicho paquete estadı́stico, se ve impedido:
no puede. R si lo permite1 . Esta es una de sus grandes ventajas.
R es un paquete estadı́stico con más de 4 000 funciones que permiten reali-
zar casi cualquier análisis estadı́stico. También se han desarrollado muchı́simos
paquetes (colecciones de funciones) que han enriquecido R. Además, permite
al usuario crear sus propias funciones.
Las funciones son los bloques de construcción en R [148, 150]. Como todo
en R son objetos [161], las funciones también; por lo tanto se les puede aplicar
todo lo que hemos aprendido sobre ellos: atributos, clase, print, etc.
Como su conocimiento es básico para avanzar en R, este capı́tulo se dedica
a estudiar sus caracterı́sticas, tipos y comportamiento.
24.1. Componentes de una función

Las funciones en R tienen un comportamiento similar a las funciones en
Matemáticas, en que toman uno o más argumentos (inputs) y producen uno o
más resultados (outputs) [150]. Aunque para mucha gente, una función es como
una caja negra, en la que por un lado se introducen datos y por otro se obtiene
un resultado. Lo que hace por dentro está oculto a los ojos del usuario.
La estructura de una función puede ser analizada con el siguiente código,
en el que se declara el objeto f() como una función.
#---------------------------------------------------------------
f <- function(...) {
# comprobación de condiciones
1 Según Chambers: ((Writing functions is the natural way to expand what you can do with the system)).
[161]
301
302 CAPÍTULO 24. PROGRAMACIÓN DE FUNCIONES
...
# cálculos internos
...
# resultado
...
}
#---------------------------------------------------------------
En este objeto f() se observan varias partes [148], presentadas en la si-

guiente Figura 24.1:
Figura 24.1: Las tres partes de una función.
Componentes de una
FUNCIÓN
ARGUMENTOS CUERPO ENTORNO
formals() body() environment()
24.1.1. Argumentos
Son la lista de argumentos que controlan cómo se puede llamar a la función.
Se explora con la función formals(), que devuelve una lista con todos los
argumentos que utiliza la función. Si la función es primitiva devuelve NULL.
Ejemplo 24.1. ¿Cuáles son los argumentos de la función chisq.test()?
> formals(chisq.test)
$x
$y
NULL
$correct
[1] TRUE
$p

24.1. COMPONENTES DE UNA FUNCIÓN 303
rep(1/length(x), length(x))
www.editorialuc.es
$rescale.p
[1] FALSE
$simulate.p.value
[1] FALSE
$B
[1] 2000
La función formals() devuelve una lista con 7 argumentos: x, y, correct,

p, rescale.p, simulate.p.value y B. Cuando utilizamos la función args()
obtenemos los argumentos de una manera más compacta:
Ejemplo 24.2. Liste los argumentos de la función chisq.test().
> args(chisq.test)
function (x, y = NULL, correct = TRUE, p = rep(1/length(x), length(x)),
rescale.p = FALSE, simulate.p.value = FALSE, B = 2000)
NULL
Y aún más compacta con formalArgs().
24.1.2. Cuerpo
El cuerpo de una función es el código que hay dentro de la función, es decir,
todo lo encerrado entre las dos llaves.
Se explora con la función body().
Ejemplo 24.3. ¿Qué instrucciones (o trabajo interior) realiza la función

shapiro.test()?
> body(shapiro.test)
{
DNAME <- deparse(substitute(x))
stopifnot(is.numeric(x))
x <- sort(x[complete.cases(x)])
n <- length(x)
if (is.na(n) || n < 3L || n > 5000L)
stop("sample size must be between 3 and 5000")
rng <- x[n] - x[1L]
if (rng == 0)
stop("all ’x’ values are identical")
if (rng < 1e-10)
x <- x/rng
res <- .Call(C_SWilk, x)
RVAL <- list(statistic = c(W = res[1]), p.value = res[2],
method = "Shapiro-Wilk normality test", data.name = DNAME)
class(RVAL) <- "htest"
return(RVAL)
}
24.1.3. Entorno
Es el mapa que indica dónde están colocadas las variables de la función.

Se explora con la función environment().
Ejemplo 24.4. Explore los tres componentes de la siguiente función que cal-
cula el logaritmo natural y el logaritmo decimal de un número y cuyo código
presentamos:
#---------------------------------------------------------------
> # programación de la función
> f <- function(x){
+ a <- log(x) # logaritmo neperiano
+ b <- log10(x) # logaritmo decimal
+ res <- cbind(LN = a, LD = b) # vector numérico resultado
+ res # resultado
+ }
#---------------------------------------------------------------
En primer lugar imprimimos el código de la función tecleando simplemente

su nombre:
> # código de la función
> f
function(x){
a <- log(x) # logaritmo neperiano
b <- log10(x) # logaritmo decimal
res <- cbind(LN = a, LD = b) # vector numérico resultado
res # resultado
}
y ahora vamos a explorar las tres partes de la función:

> # las tres partes de la función:
> formals(f) # ¿qué argumentos tiene?
$x
> body(f) # cuerpo de la función

{
a <- log(x)
b <- log10(x)
res <- cbind(LN = a, LD = b)
res
}
> environment(f) # entorno donde fue creada

Se trata de una función que admite un único parámetro (x), calcula su lo-
garitmo neperiano y decimal y los concatena en un vector resultado. Cuando
exploramos el cuerpo de la función con body() se pierden los comentarios. La
función f() fue creada en el entorno Global.
Hay una excepción a esta regla y son las Funciones Primitivas, del paque-
te base que no contienen código R sino código C, por lo que formals(),
body() y environment() ofrecen resultado NULL.
Ejemplo 24.5. Imprima el código y compruebe si la función mean() es una

función primitiva.

24.2. CARACTERÍSTICAS DE LAS FUNCIONES 305
UseMethod("mean")
<bytecode: 0x106cf04a0>
www.editorialuc.es
<environment: namespace:base>
> formals(mean)
$x
$...
> body(mean)
UseMethod("mean")
> environment(mean)
No es una función primitiva.
Ejemplo 24.6. Imprima el código y compruebe si la función sum() es una

función primitiva.
> sum
function (..., na.rm = FALSE) .Primitive("sum")
> formals(sum)
NULL
> body(sum)
NULL
> environment(sum)
NULL
Es una función primitiva.
Ejemplo 24.7. Calcule los logaritmos de los números naturales 1:10 con la
función f().
> f(1:10)
LN LD
[1,] 0.0000000 0.0000000
[2,] 0.6931472 0.3010300
[3,] 1.0986123 0.4771213
[4,] 1.3862944 0.6020600
[5,] 1.6094379 0.6989700
[6,] 1.7917595 0.7781513
[7,] 1.9459101 0.8450980
[8,] 2.0794415 0.9030900
[9,] 2.1972246 0.9542425
[10,] 2.3025851 1.0000000
24.2. Caracterı́sticas de las funciones

24.2.1. Escribiendo una función
Cuando escriba una función deberá contemplar los siguientes diez aspec-
tos:

1. Nombre de la función. El nombre de la función debe comenzar por una le-

tra y el resto pueden ser letras, números o un guión bajo (aunque se pue-
de, no utilice puntos en los nombres de las funciones). El nombre debe re-
cordar al usuario para qué sirve dicha función; por ejemplo, xxsdfg()
no parece un nombre adecuado porque no dice nada sobre su utilidad,
mientras que media() sı́ es un nombre correcto, porque indica que cal-
culará una media. Los nombres en R son sensibles a las mayúsculas, es
decir, el mismo nombre en mayúscula y en minúsculas son dos funciones
diferentes.
2. Operador de asignación <-. Este operador asigna la función al nombre de
la función, de forma que cuando se teclee ese nombre se ejecutará la fun-
ción. Debe llevar un espacio por delante y otro por detrás.
3. La declaración function. Esta palabra es fundamental para definir lo que
sigue como una función. Debe escribirse en minúscula. Inmediatamente
detrás, sin ningún espacio intermedio, viene el paréntesis de apertura
para incluir los parámetros.
4. Argumentos. Son los objetos (datos) que se pasan para que la función tra-
baje con ellos. Si no tienen nombre (argumentos posicionales) se deberán
pasar en el mismo orden en que están definidos, pero si tienen nombre
(argumentos nominados) se pueden pasar en cualquier orden. Por ejem-
plo una función que tenga 6 argumentos numéricos f(arg1, arg2,
arg3, arg4, arg5, arg6) a los que se va a pasar los valores x1, x2,
x3, x4, x5, x6, se deberá teclear f(x1, x2, x3, x4, x5, x6) o puede
también f(x1, x2, x6=x6, x5=x5, x3, x4).
Los argumentos pueden especificarse por posición, por nombre completo
y por nombre parcial. Por posición se suele aplicar a los dos o tres prime-
ros (se deben poner en su orden estricto), por nombre al resto (y entonces
se pueden poner en cualquier orden). Cuando el nombre es completo
(perfect matching) no hay ningún problema. Cuando el nombre es incom-
pleto se deben emplear tantas letras como sea necesario para evitar con-
fusión. Lo aconsejable es utilizar el nombre completo de los argumentos.
A los argumentos a veces se les asigna valores por defecto, que los los que
adopta con más frecuencia, por ejemplo, en funciones que implican el uso
del error tipo I se suele poner alpha = 0.05 por ser al valor utilizado
con más frecuencia.
A veces se pone como otro argumento más los tres puntos ((...)) indican
que se pueden pasar más argumentos, generalmente los que controlan
los parámetros gráficos.
Ejemplo 24.8. En el tema anterior se programó la función Fecu 2g()

en la que uno de los parámetros eran los tres puntos. Esto permite pa-
sar, por ejemplo, el argumento ltype = 2 para que dibuje la parábo-
la con una lı́nea de trazos discontinuos. Compruébelo para la ecuación
0,08x2 − 4x + 8.
> Fecu_2g(0.08, -4, 8,

+ x_inf = 0, x_sup = 50, lty = 2,

24.2. CARACTERÍSTICAS DE LAS FUNCIONES 307
+ ylim = c(-50, 10), info = TRUE)
SOLUCIONES DE LA ECUACIÓN DE 2o GRADO
www.editorialuc.es
=====================================
Ecuación.....: 0.08 x? - 4 x + 8
Soluciones x1: 2.087

x2: 47.913
Semiparámetro: 6.25
Vértice......: (25, -42)
Foco.........: (25, -38.875)
x1 x2
2.087122 47.912878
Figura 24.2: Parábola de trazo discontinuo.
Soluciones a la ecuación de 2º grado

0.08 x² − 4 x + 8
10
● ●
−10 0
f(x)
−30
●
−50
0 10 20 30 40 50
5. Llave de apertura. Obligatoria. Indica cuándo empieza el código de la fun-

ción. Nunca debe ir ella sola en un renglón de código.
6. Comprobación de condiciones. Aunque no es obligatorio, en programación

es una buena práctica de cara a evitar errores. Conviene comprobar que
los argumentos que se han pasado son los que tienen que ser. Por ejem-
plo, si esperamos un vector numérico, no debe pasarse un vector de ca-
racteres o una matriz.
Ejemplo 24.9. ¿Se comprueban las condiciones en Fecu 2g()?
7. Cuerpo de la función. Es el código de programación que realiza el trabajo

de la función. Aquı́ debe escribirse el código correspondiente a lo que la
función deba realizar.
Cuando se explora el cuerpo de una función con body() se pierden los
comentarios.
Ejemplo 24.10. Imprima las primeras lı́neas de la función Fencu 2g()

con body().

> body(Fecu_2g)
{
signo1 <- ifelse(B < 0, paste("-", abs(B)), paste("+", B))
signo2 <- ifelse(C < 0, paste("-", abs(C)), paste("+", C))
coef2 <- ifelse(A == 1, "", ifelse(A == -1, "-", A))
signo1 <- ifelse(signo1 == "+ 1", "+", ifelse(signo1 == "- 1",
"-", signo1))
ecu <- paste(coef2, "x?", signo1, "x", signo2)
ver <- c(-B/(2 * A), -(Bˆ2 - 4 * A * C)/(4 * A))
p <- 1/(2 * A)
alfa <- -B/(2 * A)
beta <- (4 * A * C - Bˆ2)/(4 * A)
dis <- Bˆ2 - 4 * A * C
if (dis < 0) {
A <- A + (0+0i)
B <- B + (0+0i)
C <- C + (0+0i)
}
dis <- Bˆ2 - 4 * A * C
---------- lı́neas omitidas -------------
res
}
Apreciará que han desaparecido los comentarios...

Para desarrollar buenos hábitos de programación es preferible escribir
código claro que no código inteligente2 . Por supuesto, siempre bien do-
cumentado.
8. Resultado de la función. Casi todas las funciones devuelven un resultado.
A veces no interesa ver nada, por lo que el resultado se declara invisible
con la función invisible(). Generalmente las funciones devuelven un
objeto que suele ser una lista, para que posteriormente el usuario pueda
acceder fácilmente a cada uno de sus componentes.
Es deseable tener en cuenta las siguientes consideraciones:
Es más elegante no emplear la función return() como salida de
una función.
No debe haber varias salidas.
Cuando no hay ninguna salida, la función devuelve NULL.
9. Llave de cierre. Obligatoria. Indica cuándo acaba el código de la función.
Suele ir ella sola en un renglón final.
10. Documentación. No es obligatoria, pero ayuda mucho para entender el
código de la función, sobre todo cuando transcurra el tiempo desde que
se programó. Se teclea una almohadilla # y a continuación el texto que
considere adecuado.
24.2.2. Ámbito de una función

El ámbito (lexical scoping) de una función es el conjunto de reglas que go-
biernan cómo R busca el valor de un sı́mbolo [148].
R tiene dos ámbitos:
2 En palabras de Owen et al. ((Good programming is clear rather than clever. Being clever is good, but
given a choice, being clear is preferable)) [150].

24.3. CLASES DE FUNCIONES 309
Ámbito léxico (lexical scoping). Indica cómo R mira los valores de los sı́mbo-
los cuando fueron creados. R usa los valores definidos dentro de la fun-
www.editorialuc.es
ción y si no encuentra alguno le busca en un nivel superior. Igual com-
portamiento sigue para las funciones.
Ámbito dinámico (dynamic scoping). R mira los valores cuando ejecuta la fun-
ción, de manera que puede ofrecer resultados diferentes cuando mira
algún valor fuera de su entorno que ha podido cambiar.
24.3. Clases de funciones

Las funciones pueden ser clasificadas de muchas maneras, lo que da pie a
que parezca que hay muchos tipos de funciones.
Se pueden distinguir, teniendo en consideración:
Nombre. Permite distinguir dos tipos:
Nominadas. Son la mayorı́a. Por ejemplo mean(). El nombre per-
mite su ejecución.
Sin nombre o anónimas (anonymous functions). Son funciones que
no tienen un nombre asignado3 . Son muy convenientes cuando son
muy cortas y pueden ser llamadas por otra función [146].
Origen. Se diferencian dos tipos:
Funciones que forman parte del sistema (built-in functions o BIF)
Funciones programadas por el usuario (user-written or user-defined
functions o UDF). Una de las fortalezas de R es la capacidad de usar
las funciones definidas por los usuarios.
Comportamiento. Ante diferentes argumentos pueden comportarse:
> set.seed(2016)
> x <- sample(1000, 100)
> y <- abs(rnorm(100))+log(x)
> z <- cut(x, breaks = 4, labels=letters[1:4])
Funciones inmutables (normal functions) Son las funciones cuyo com-

portamiento siempre es el mismo. Por ejemplo log10(), siempre
calcula el logaritmo decimal.
Funciones mutables (generic functions) Son aquellas funciones cuyo
comportamiento varı́a dependiendo de la clase de objetos sobre los
que trabajan4 . Por ejemplo, print(), plot(), summary().
Cuando se llama a una función genérica, ésta examina a qué clase
pertenece su primer argumento y a continuación elige otra función
de acuerdo con esa clase [150]. Por ejemplo, tecleando el nombre de
la función se imprime en consola su código, pero en el caso de una
función genérica:
3 Según Venables y Ripley: ((an anonymous function is a argument list and body used inline, without
being given a name)). [151]

4 Según Muenchen: ((R has some special functions called generic functions: they accept multiple clas-
ses of objects and change their processing accordingly.)) [232].

> mean
function (x, ...)
UseMethod("mean")
<bytecode: 0x103c585f8>
El código de la función consiste en que simplemente llama a la fun-

ción UseMethod() y le pasa como argumento "mean". Si la clase
de x es un número llama a la función mean.default(), cuyo códi-
go es:
> mean.default
function (x, trim = 0, na.rm = FALSE, ...)
{
if (!is.numeric(x) && !is.complex(x) && !is.logical(x)) {
warning("argument is not numeric or logical: returning NA")
return(NA_real_)
}
if (na.rm)
x <- x[!is.na(x)]
if (!is.numeric(trim) || length(trim) != 1L)
stop("’trim’ must be numeric of length one")
n <- length(x)
if (trim > 0 && n) {
if (is.complex(x))
stop("trimmed means are not defined for complex data")
if (anyNA(x))
return(NA_real_)
if (trim >= 0.5)
return(stats::median(x, na.rm = FALSE))
lo <- floor(n * trim) + 1
hi <- n + 1 - lo
x <- sort.int(x, partial = unique(c(lo, hi)))[lo:hi]
}
.Internal(mean(x))
}
<bytecode: 0x103c58140>
Si la clase de x es una fecha llama a la función mean.Date(), etc.

Para ver todos sus métodos hemos de utilizar methods():
#-----------------------------------------------------
methods(generic.function, class)
#-----------------------------------------------------
Ejemplo 24.11. ¿Qué métodos hay para la función mean()?
> methods(mean)
[1] mean.Date mean.default mean.difftime mean.POSIXct
[5] mean.POSIXlt
Ejemplo 24.12. ¿Qué métodos hay para la función boxplot()?
> methods(boxplot)
[1] boxplot.default boxplot.formula* boxplot.matrix

El código de los métodos marcados con un asterisco se ven con la

función getAnywhere.
www.editorialuc.es
Ejemplo 24.13. ¿Cómo se comporta summary() ante un vector
numérico o ante un objeto de la clase lm?
El comportamiento de summary() ante un vector numérico:
> summary(x) # vector numérico
Min. 1st Qu. Median Mean 3rd Qu. Max.
3.0 193.0 450.0 482.9 767.5 999.0
El comportamiento de summary() ante un objeto de la clase lm:

> summary(lm(y ˜ x)) # objeto lm
Call:
lm(formula = y ˜ x)
Residuals:
-3.8849 -0.4666 -0.0961 0.5054 2.2995
Coefficients:
(Intercept) 5.3091959 0.1541281 34.45 <2e-16 ***
x 0.0029135 0.0002714 10.74 <2e-16 ***
---
Signif. codes: 0 ‘***’ 0.001 ‘**’ 0.01 ‘*’ 0.05 ‘.’ 0.1 ‘ ’ 1

summary() con un vector numérico numérico ofrece una informa-

ción diferente que la que proporciona con un objeto de la clase lm.
Ejemplo 24.14. ¿Cómo se comporta plot() ante diferentes obje-

tos?
> plot(x, pch = 16, col= 3)
> plot(y ˜ x, pch = 16, col = 6)
> plot(x ˜ z, col = 2:5)
> plot(z, col = 4:7)
plot() adapta su comportamiento a la clase de objetos que maneja

y puede ofrecer un gráfico de puntos, un scatterplot, un boxplot o
un diagrama de barras.

Tabla:

Figura 24.3: Diferente comportamiento de plot().

1000
1000
30
● ● ●
● ●
●● ● ●
●
● ● ●
● ●
● ● ● ●
● ● ●
● ● ●
● ● ●
25
● ● ●
●●
800
800
● ● ● ●
8
● ● ● ● ● ● ●
● ●
● ●●● ● ● ●
● ●
● ●● ● ● ●● ● ● ●
● ●● ● ● ●●● ●
● ●● ● ●● ● ●●
20
● ● ●
●● ● ● ●
● ● ● ● ●
● ●● ● ●
600
600
● ● ●
●● ● ● ● ●
● ● ● ●●●
6
● ●●●
● ● ●●
● ●
●
●
15
x
x
● ● ● ● ●●●
●
● ● ● ●●
● ● ●
400
400
● ●
●● ● ● ●
● ● ● ●
●
10
● ● ●
4
● ●
● ● ●
● ●● ●
200
200
●
● ● ● ●● ●
● ●● ●●
5
●● ● ●
●
● ● ●●
2
● ● ● ●
●
● ●
0
0
0 20 40 60 80 100 0 200 400 600 800 1000 a b c d a b c d
Index x z
Función Acción
abs() Valor absoluto
args() Argumentos de una función
body() Cuerpo de una función
cbind() Concatena por columnas
class() Determina la clase de un objeto
complete.cases() Selecciona los casos de un data frame sin missings
cut() Categoriza una variable numérica
deparse() Influye sobre caracteres
environment() Entorno de una función
f() Función f()
Fecu 2g() Soluciones a una ecuación de segundo grado
floor() Redondea ((a la baja))
formals() Argumentos de una función
formalsArgs() Argumentos de una función
function() Declaración de una función
getAnywhere() Visualiza código de métodos ocultos
ifelse() Ejecución condicional
invisible() Hace invisible lo que devuelve una función
is.complex() Comprueba si es un número complejo
is.logical() Comprueba si es un vector lógico
is.numeric() Comprueba si es numérico
log() Logaritmo neperiano
log10() Logaritmo decimal
mean.default() Calcula la media en un vector numérico (por defecto)
par() Fija parámetros gráficos

Función Acción
paste() Une objetos en una cadena
www.editorialuc.es
plot() Función gráfica por excelencia
rep() Repite elementos para formar un vector
return() Salida de una función
shapiro.test() Test de normalidad
sort() Ordena un objeto
stop() Detiene la ejecución de una función
stopifnot() Detención condicional
substitute() Substitución de caracteres
sum() Suma de un vector
summary() Función genérica de resumen
UseMethod() Métodos usados por las funciones genéricas
warning() Pone un aviso
PROBLEMAS
Problema 1. Incluya al principio del cuerpo de la función Fecu 2g() código en R
que compruebe que los coeficientes del polinomio son objetos numéricos.
Problema 2. Programe una función que calcule la suma de los primeros 100 núme-
ros:
n=100
X
i
i=1
Problema 3. Programe una función que calcule la suma de los primeros 100 números
al cuadrado (cada número elevado al cuadrado):
n=100
X
i2
i=1
Problema 4. Programe una función que calcule la suma de los primeros 100 números
al cubo (cada número elevado al cubo):
n=100
X
i3
i=1
Problema 5. ¿Qué métodos existen para la función var()?

Problema 6. Imprima el código del método boxplot.default().
Problema 7. Escriba un programa con un único parámetro, un texto. Deberá cal-
cular el número de palabras que contiene dicho texto después de haberle converti-
do a minúsculas. Además debe contar el número de letras empleadas y con qué fre-
cuencia aparece cada una de ellas ası́ como los puntos y comas. Como texto de
ejemplo deberá usar el siguiente: El programa R, herramienta clave en
investigación. I Lenguaje R.

Problema 8. Si el error es el valor absoluto entre el valor verdadero y el valor calcu-

lado y sabiendo que:
n
X n2 (n + 1)2
i3 =
i=1
4
¿Qué error cometió en el problema 4?

Problema 9. Se define la longitud de un vector como:
v
u n
uX
t x2i
i=1
Escriba un programa que calcule la longitud euclı́dea de un vector numérico.

Problema 10. Escriba un programa que permita obtener los 7 números para rellenar
un boleto de Loterı́a Primitiva.

www.editorialuc.es
Capı́tulo 25
Estructuras de control
Un programa es una lista de comandos, escritos en un fichero (script), que se

ejecutan uno detrás de otro. Constan de tres partes: entrada, trabajo interno y
salida. Es deseable que dispongan de una cuarta parte, muchas veces olvidada,
consistente en frases explicativas de qué hace (documentación) [150].
Una tarea previa y muy importante en programación es definir nuestro en-
torno de trabajo y limpiarle de variables extrañas que puedan interferir con las
que se están programando, para lo cual se puede ejecutar rm(list = ls()),
pero hay que estar seguros, porque borrará objetos que tal vez hayamos pro-
gramado y nos interese conservar...
En este tema aprenderemos a manejar adecuadamente los diferentes ope-
radores y bucles existentes en el lenguaje R, pues se tratan de las herramientas
básicas de programación [146, 148, 150, 151, 161]. Además, haremos una intro-
ducción a las técnicas de depuración para corregir posibles errores en el código
que escribamos.
En programación es mucho más importante escribir código claro y bien
documentado que código muy inteligente, ya que en programación se dedica
mucho tiempo a corregir y depurar código, por tanto, esta tarea será más fácil
cuanto más claro el código escrito.
En R todos los comandos se ejecutan secuencialmente, las expresiones u
asignaciones van haciendo su trabajo y según indiquen, imprimen o no un
resultado:
x <- 2 # asignación, no imprime
sin(x) # expresión, sı́ imprime
y <- cos(x) # asignación
y # impresión
(z <- tan(x)) # asignación e impresión
print(x) # impresión
show(x) # impresión
rm(x, y, z) # borrar objetos no necesarios
Cuando los comandos se encierran entre llaves, se van ejecutando secuen-
cialmente, pero el resultado de todo el bloque entre llaves será el resultado de
la última expresión evaluada:
expresión1; expresión2; expresión3, ..., expresiónN
si expresiónN es por ejemplo sum(1+2+3) se obtendrá como resultado 6, in-
dependientemente de que en las expresiones anteriores haya realizado cálculos
315
316 CAPÍTULO 25. ESTRUCTURAS DE CONTROL
muy complejos tipo regresión logı́stica, integrales, etc. Esto es lo que sucede en
las funciones, como veremos más adelante, en que todo el cuerpo de la función
está encerrado entre llaves y la última expresión será el resultado de la función.
En muchas ocasiones interesa implementar algún mecanismo que permita
la ejecución de un aparte del código si se cumple una condición especı́fica,
o que se repita la ejecución de un bloque de código determinado número de
veces. Este tipo de control en R se realiza mediante:
25.1. Ejecución condicional

Cuando se quiere forzar la ejecución de alguna parte del programa según
el resultado de la evaluación de una condición lógica se ejecuta una estructura
de control. Hay diferentes estructuras que permiten la ejecución condicional
(Figura 25.1).
Figura 25.1: Ejecución del flujo en un script.
Estructuras de control
Ejecución
Condicional Repetitiva
if() ifelse() switch() for repeat while
25.1.1. if
Solo evalúa una condición lógica y si se cumple se ejecuta un código escrito
entre corchetes, si no se cumple salta a la siguiente orden.
#--------------------------------------
if (logical_expression) {
expression1
...
}
#--------------------------------------

25.1. EJECUCIÓN CONDICIONAL 317
Cuando lo que hay entre corchetes es una única expresión, se puede escribir
en la misma lı́nea del if y sin corchetes, aunque es preferible poner siempre
www.editorialuc.es
los corchetes.
La evaluación de la condición lógica arrojara TRUE o FALSE. Si la evalua-
ción lógica se efectúa sobre un vector, solo se hace sobre el primer elemento
Ejemplo 25.1. Genere un resultado aleatorio de entre dos opciones y presen-

te un resultado diferente según el resultado obtenido.
> dia <- c(’soleado’, ’lluvioso’)

> x <- sample(dia, 1)
> if (x == ’soleado’) print(’Salir a pasear’)
[1] "Salir a pasear"
25.1.2. if else
Aquı́ siempre se ejecuta un bloque de código, el bloque uno ({cons.expr})
si se cumple o el bloque dos ({alt.expr}) si no se cumple.
#--------------------------------------
if (logical_expression) {
expression_1
...
} else {
expression_2
...
}
#--------------------------------------
Ejemplo 25.2. Añada una segunda opción al ejemplo anterior.
> dia <- c(’soleado’, ’lluvioso’)

> x <- sample(dia, 1)
> if (x == ’soleado’) {
+ print(’Salir a pasear’)
+ } else {
+ print(’Permanecer en casa’)
+ }
[1] "Permanecer en casa"
Es posible que haya obtenido otro resultado has que la selección del dı́a es
aleatoria.
Ejemplo 25.3. Genere un número aleatorio según una distribución de Pois-

son y compruebe si es par o no.
> x <- rpois(1, 10)

> x
[1] 6
> if (x %% 2 == 0) {
+ print(’Es par’)
+ } else {
+ show(’Es impar’)

+ }
[1] "Es par"
La palabra reservada else no puede comenzar una nueva lı́nea porque R

darı́a un error:
> x <- sample(1:50, 1)

> if (x %% 2 == 0) print(’Par’)
> else print(’Impar’)
Error: inesperado ’else’ in "else"
Para evitar este error, o else debe estar en la misma lı́nea que if, o hay
que usar llaves.
> x <- sample(1:50, 1) # Solución 1

> if (x %% 2 == 0) print(’Par’) else # else en la misma lı́nea
+ print(’Impar’)
[1] "Par"
>
> x <- sample(1:50, 1) # Solución 2
> if (x %% 2 == 0) {print(’Par’) # se usan llaves para que
+ } else print(’Impar’) # else no empieze la lı́nea
[1] "Par"
La evaluación lógica no es vectorizada, por lo que Rsolo tiene en cuenta el

primer elemento del vector:
Ejemplo 25.4. La evaluación lógica no es vectorizada. Dado un vector de

números enteros, escriba un programa que diga si son positivos o negativos.
> x <- c(2, 3, -5, 6, -2, 8)

> if (x > 0) {
+ texto <- ’positivo’
+ } else {
+ texto <- ’negativo’
+ }
Warning message:
In if (x > 0) { :
la condición tiene longitud > 1 y sólo el primer elemento será usado
> data.frame(x = x, texto = texto)
x texto
1 2 positivo
2 3 positivo
3 -5 positivo
4 6 positivo
5 -2 positivo
6 8 positivo
Al ejecutar este programa observamos que R presenta un mensaje de aviso

notificándonos que solo tiene en cuenta el primer elemento, que no es lo que
queremos. Debido a esto el resultado es erróneo, ya que nos dice que ¡-5 y -2
son números positivos!
La forma de solucionar este problema es obligándole a que evalúe cada uno
de los elementos del vector, lo que se puede hacer de dos formas:

Recorriendo uno a uno cada elemento con for. Aunque lo veremos más
adelante, ponemos aquı́ la solución:
www.editorialuc.es
> x <- c(2, 3, -5, 6, -2, 8)
> texto <- character(length(x))
> for (i in 1:(length(x))) {
+ if (x[i] > 0) {
+ texto[i] <- ’positivo’
+ } else {
+ texto[i] <- ’NEGATIVO’
+ }
+ }
x texto
1 2 positivo
2 3 positivo
3 -5 NEGATIVO
4 6 positivo
5 -2 NEGATIVO
6 8 positivo
Empleando una función vectorizada con ifelse(), como veremos en el

siguiente apartado.
La condición que se evalúa puede ser más compleja: se pueden mezclar

varias condiciones utilizando los operadores boleanos AND (((&))) y OR (((|))).
Ejemplo 25.5. Extraiga aleatoriamente 50 números naturales de entre 1 y

200. Evalúe a la vez si el primero de ellos es múltiplo de 2 o de 3 o de 7.
> set.seed(2016) # se fija la semilla aleatoria

> x <- sample(1:200, 50) # 50 extracciones aleatorias [1,200]
> x[1] # primer número extraido
[1] 37
> if (x %% 2 == 0 | x %% 3 == 0 | x %% 7 == 0) {
+ print(’x es múltiplo de 2 o 3 o 7’)
+ } else {
+ print(’x no es múltiplo ni de 2, ni de 3, ni de 7’)
+ }
[1] "x no es múltiplo ni de 2, ni de 3, ni de 7"
Warning message:
In if (x%%2 == 0 | x%%3 == 0 | x%%7 == 0) { :
la condición tiene longitud > 1 y sólo el primer elemento será usado
Aquı́ generamos un vector de 50 números comprendidos entre el 1 y el 200,

x := 127, 64, ..., 65, y el primer número (127) no es divisible por 2 ni por 3 ni
por 7, de hecho es un número primo. Tras ejecutar el código nos informa de
esto mismo. Pero al mismo tiempo aparece un mensaje diciéndonos que de los
50 números del vector x, únicamente utiliza el primero para ser sometido a
la evaluación de las condiciones. Esto se debe a que los operadores ((|)) y ((&))
trabajan con todo el vector aunque solo valoran el primer elemento, mientras
que si hubiésemos utilizado los operadores ((||)) y ((&&)) que solo trabajan con
el primer elemento no nos habrı́a aparecido ningún mensaje de aviso (pero
seguirı́an valorando la condición lógica con el primer elemento):

> if (x %% 2 == 0 || x %% 3 == 0 || x %% 7 == 0) {
+ print(’x es múltiplo de 2 o 3 o 7’)
+ } else {
+ print(’x no es múltiplo ni de 2, ni de 3, ni de 7’)
+ }
[1] "x no es múltiplo ni de 2, ni de 3, ni de 7"
A los operadores ((||)) y ((&&)) se les llama short-circuit evaluation [160] por-
que además de no ser vectorizados se evalúan de izquierda a derecha, es decir,
que solo se evalúa la condición de la derecha si la de la izquierda es TRUE, de
lo contrario no se evalúa. Esto evita errores y hace que el programa sea más
rápido.
25.1.3. ifelse()
Es una versión más corta de if/else en el que se evalúa si cada uno de los
elementos de un vector cumple una condición; si la cumple se adopta la ex-
presión ((A)) y si no la cumple se adopta la expresión ((B)). Se genera un vector
de la misma longitud que el vector evaluado, en el que cada elemento vale
((A)) o ((B)) según cumpla o no la condición. Se trata de los llamados ((cálculos
vectorizados)).
#--------------------------------------
ifelse(logical_expression, A, B)
#--------------------------------------
Ejemplo 25.6. Resuelva el ejemplo 4 con la función vectorizada ifelse().
> x <- c(2, 3, -5, 6, -2, 8)

> texto <- ifelse(x > 0, ’positivo’, ’NEGATIVO’)
x texto
1 2 positivo
2 3 positivo
3 -5 NEGATIVO
4 6 positivo
5 -2 NEGATIVO
6 8 positivo
Ahora el código es más sencillo...
Ejemplo 25.7. Compruebe la condición de multiplicidad por 2 o por 3 o por

7 en los primeros 10 números del vector x generado en el ejercicio anterior.
> (y <- x[1:10])

[1] 37 29 167 27 94 24 120 172 1 11
> z <- ifelse(y %% 2 == 0 | y %% 3 == 0 | y %% 7 == 0,
+ ’múltiplo de 2 o 3 o 7’,
+ ’no es múltiplo ni de 2, ni de 3, ni de 7’)
> z
[1] "no es múltiplo ni de 2, ni de 3, ni de 7"

[4] "múltiplo de 2 o 3 o 7"

www.editorialuc.es
rm(x, y, z)
El que ifelse() permita cálculos vectorizados es muy útil, por ejemplo,

para poner diferente color a los puntos de un gráfico de nube de puntos:
Ejemplo 25.8. Lea la BdD PimaESP.xls y represente gráficamente la nube

de puntos formada por IMC (en ordenadas) y la Edad (en abscisas) con los
puntos coloreados en rojo si las indias Pima son diabéticas y en verde si no
lo son.
> pima <- read.table(file = ’df_pima.csv’,

+ header = TRUE, sep = ’;’, dec = ’,’)
> with(pima, plot(IMC ˜ Edad, las = 1, pch=16,
+ col = ifelse(Diab == ’No’, 3, 2)))
Figura 25.2: Nube de puntos (Edad, IMC) de la BdD de indias Pima, coloreados según
son o no diabéticas, utilizando la función ifelse().
25.1.4. ifelse() anidados

En ocasiones se pueden anidar varios ifelse():
Ejemplo 25.9. Clasifique el estado nutricional de las indias Pima como nor-
mal (IMC ¡25 kg/m2 ), con sobrepeso (IMC ¡30 kg/m2 ) y como obesas (IMC ≥
30 kg/m2 ).

> pima$EN <- ifelse(pima$IMC >= 30, ’Obesidad’,

+ ifelse(pima$IMC >= 25, ’Sobrepeso’, ’Normal’))
> with(pima, table(Diab, EN))
EN
Diab Normal Obesidad Sobrepeso
No 76 221 118
S\x92 3 177 34
Este código tiene mucha utilidad a la hora de crear nuevas variables deri-
vadas en BdD de proyectos de investigación.
25.2. Ejecución repetitiva

Muchas veces interesa que se ejecute repetidamente un bloque de código.
Hay varias construcciones que lo permiten. Todas admiten break y next. Las
funciones de ((vueltas)) for, while, repeat son de tipo especial, compruébelo
tecleando: typeof(‘for‘)
25.2.1. for
Cuando se desea una ejecución un determinado número de veces [160], o
una secuencia de veces se escribe entre paréntesis una variable de ((vueltas)) y
un vector de secuencia. Se ejecutará el código mientras var in seq sea cierto.
#---------------------------------------------------------------
for(var in seq) expr
#---------------------------------------------------------------
Ejemplo 25.10. Tres ejemplos de uso de for.
> x <- c(12, 22, 28, 41)

> # ejemplo 1
> for (i in 1:4) print(i)
[1] 1
[1] 2
[1] 3
[1] 4
> # ejemplo 2
> for (i in x) {print(i); print(x + i)}
[1] 12
[1] 24 34 40 53
[1] 22
[1] 34 44 50 63
[1] 28
[1] 40 50 56 69
[1] 41
[1] 53 63 69 82
> # ejemplo 3
> for (i in seq(0, 80, 20)) print(i)
[1] 0
[1] 20
[1] 40

25.2. EJECUCIÓN REPETITIVA 323
[1] 60
[1] 80
www.editorialuc.es
> rm(x, i)
Ejemplo 25.11. Programe una función que imprima los primeros 50 números
de la serie de Fibonacci.
> Ffibonacci <- function(n) {

+ fibo <- numeric(n)
+ fibo[1] <- fibo[2] <- 1
+ for (i in 3:n) {
+ fibo[i] <- fibo[i - 2] + fibo[i - 1]
+ }
+ fibo
+ }
> Ffibonacci(50)
[1] 1 1 2 3 5
[6] 8 13 21 34 55
[11] 89 144 233 377 610
[16] 987 1597 2584 4181 6765
[21] 10946 17711 28657 46368 75025
[26] 121393 196418 317811 514229 832040
[31] 1346269 2178309 3524578 5702887 9227465
[36] 14930352 24157817 39088169 63245986 102334155
[41] 165580141 267914296 433494437 701408733 1134903170
[46] 1836311903 2971215073 4807526976 7778742049 12586269025
25.2.2. repeat
Aquı́ no se utiliza ninguna variable de ((vueltas)); el código se repite inde-
finidamente hasta que se apague el ordenador, se pulse Ctrl+C o se encuentre
una declaración break.
#---------------------------------------------------------------
repeat expr
#---------------------------------------------------------------
Ejemplo 25.12. En Cantabria de 0 a 15 años es la edad para ser atendidos

por el pediatra.
> i <- 0
> repeat {
+ if (i > 15) break
+ else {
+ cat(’\n’, i, ’años es edad pediátrica’)
+ i <- i + 1
+ }
+ }
0 años es edad pediátrica



25.2.3. while
Otras veces se repite el código mientras una condición es verdadera
#---------------------------------------------------------------
while(cond) expr
#---------------------------------------------------------------
Ejemplo 25.13. Imprima los años de la edad pediátrica.

> i <- 0
> while (i < 16) {
+ print(i)
+ i <- i + 1
+ }
[1] 0
[1] 1
[1] 2
[1] 3
[1] 4
[1] 5
[1] 6
[1] 7
[1] 8
[1] 9
[1] 10
[1] 11
[1] 12
[1] 13
[1] 14
[1] 15
El problema de la ejecución de for, while, repeat es que consumen mu-

cho tiempo, que para objetos de pequeño tamaño no tiene ninguna importan-
cia, pero trabajando con objetos de gran tamaño puede enlentecer considera-
blemente los tiempos de ejecución.
Ejemplo 25.14. Calcule los tiempos de ejecución de tres algoritmos diferen-

tes con distinto grado de eficiencia en la suma de dos vectores de 100000
elementos cada uno [160].

25.3. FUNCIONES EN ESTE TEMA 325
> # método 1 (muy ineficiente)

> x <- rnorm(100000)
www.editorialuc.es
> y <- rnorm(100000)
> z <- c()
> system.time(for (i in 1:100000) z <- c(z, x[i] + y[i]))
user system elapsed
44.50 0.13 44.77
> # método 2 (ineficiente)

> x <- rnorm(100000)
> y <- rnorm(100000)
> z <- rep(NA, 100000)
> system.time(for (i in 1:100000) z[i] <- x[i] + y[i])
user system elapsed
0.92 0.00 0.93
> # método 3 (eficiente)

> x <- rnorm(100000)
> y <- rnorm(100000)
> system.time(z <- x+y)
user system elapsed
0 0 0
25.3. Funciones en este tema

En este tema se han utilizado las funciones recogidas en la siguiente Tabla:
Función Acción
sin() Seno
cos() Coseno
if() Condición
ifelse() Condición
print() Imprimir en consola
rpois() Números aleatorios con distribución de Poisson
FleeXLS() Lee datos Excel
use() Coloca una BdD en la memoria de trabajo
plot() Gráfico de nube de puntos
data.frame() Une vectores para crear un data frame
table() Crea una tabla de contingencia
seq() Crea una secuencia
traceback() Función de depuración
while() Repetir mientras

PROBLEMAS
Problema 1. Escriba una función que calcule los marginales (total de cada una de las
filas y de cada una de las columnas) utilizando algún bucle (for o while). Compare
su tiempo de ejecución con otro método vectorizado.
Problema 2. Escriba una función que calcule los coeficientes producto de dos polino-
mios.

www.editorialuc.es
Capı́tulo 26
Primeras funciones escritas

por el usuario
En este capı́tulo vamos a programar las primeras funciones para ir adqui-

riendo un poco de práctica. Conforme avancemos, iremos adquiriendo mayor
soltura y más seguridad1 .
26.1. Programando funciones triviales

26.1.1. Primera función: Fsaludos()
Vamos a programar nuestra primera función, Fsaludos() que escribe un
saludo genérico.
> #-----------------------------------------------------------
> # Fsaludos() Saludo genérico
> #-----------------------------------------------------------
> Fsaludos <- function(
+ nombre = ’Mundo’
+ ) {
+ # comprobación de condiciones
+ if (!is.character(nombre))
+ stop(’El nombre no es una cadena de caracteres’)
+
+ # cuerpo de la función
+ nom <- toupper(nombre) # en mayúsculas
+ texto <- ’, saludos’ # texto libre
+ saludo <- paste(’Hola ’, nom, texto, sep = ’’) # saludo
+
+ # resultado de la función
+ saludo
+ }
> #--------------------------------------------fin Fsaludos()
Como hemos pasado un argumento con un valor ((por defecto)), si no pa-

samos ningún argumento, por ejemplo tecleando Fsaludos(), la función se
1 De acuerdo con John Fox cuando dice: ((Programming is a craft. Like most crafts, it is a combination
of art and science; and as is true of most crafts, facility in programming is partly the product of experience)).
[115]
327
328 CAPÍTULO 26. PRIMERAS FUNCIONES ESCRITAS POR EL USUARIO
ejecuta correctamente. Si pasamos un argumento, éste será el que utilice y no

el que tenı́a por defecto.
> Fsaludos()
[1] "Hola MUNDO, saludos"
> Fsaludos(’alumnos’)
[1] "Hola ALUMNOS, saludos"
La función trabaja también con vectores (es una función vectorizada):

> alu <- c(’Marı́a’, ’Jesús’, ’Charo’)
> Fsaludos(alu)
[1] "Hola MARÍA, saludos" "Hola JESÚS, saludos"
[3] "Hola CHARO, saludos"
> rm(alu)
Como R pone entre corchetes el número ı́ndice del primer elemento de los
que caben en cada renglón hasta que imprime todo el vector.
Visibilidad de las variables. Las variables que se crean dentro de una fun-
ción tienen vida dentro de esa función; cuando se sale de ella se pierden sus
valores y desaparecen.
> (a <- 12) # valor original de a
[1] 12
> f <- function() {
+ a <- 7
+ a # valor de a dentro de la función
+ }
> f()
[1] 7
> a # valor de a fuera de la función (sin cambios)
[1] 12
Este ejemplo nos ha servido para poner de manifiesto que la variable a en

nuestro entorno de trabajo vale 12, y que en el entorno de una función se crea
una variable a con otro valor (7) que devuelve la función, pero una vez fuera
de ella volvemos a nuestro entorno de trabajo y a sigue valiendo 12, es decir,
no ha cambiado.
Hay una forma de cambiar este comportamiento y es con el operador −,
tal y como vemos en el siguiente ejemplo:
> (a <- 12) # valor original de a
[1] 12
> f <- function() {
+ a <<- 7
+ a # valor de a dentro de la función
+ }
> f()
[1] 7
> a # valor de a fuera de la función (con cambios)
[1] 7
> rm(f, a)
Este ejemplo pone de manifiesto lo peligroso que es utilizar el operador

− ; de hecho, prácticamente todos los expertos en R desaconsejan su uso.

26.1. PROGRAMANDO FUNCIONES TRIVIALES 329
26.1.2. Segunda función: Fmedia()

Supongamos que queremos programar una función que calcule la media en
www.editorialuc.es
un vector numérico:
> #-----------------------------------------------------------
> # Fmedia() Calcula la media de un vector numérico
> #-----------------------------------------------------------
> Fmedia <- function(
+ x, # vector numérico
+ dec = 2 # decimales de redondeo
+ ) {
+ n <- length(x) # datos
+ sx <- sum(x) # suma de datos
+ m <- sx / n # media
+ round(m, dec) # media redondeada
+ }
> #-----------------------------------------------fin Fmedia()
Programamos la función rápidamente, la ejecutamos y parece que está bien

> Fmedia(c(12, 24, 45, 76, 13, 9), dec = 1)
[1] 29.8
Efectivamente, la suma de los elementos del vector 12 + 24 + 45 + 76 +

13 + 9 = 179 dividido por el número de elementos (6) es la media (179/6 =
29,8333333333), que redondeada a un único decimal se queda en 29.8; parece
que todo está bien.
Pero hemos cometido varios errores:
1. No hemos documentado adecuadamente, de forma que cuando unos
meses más tarde queramos revisar este código tal vez no lo entenda-
mos bien. Por supuesto cuando el código son pocas lı́neas –como en este
ejemplo– no pasa nada, pero cuando son varias decenas es posible no nos
acordamos bien.
2. Falta el apartado de comprobación de los argumentos. Cuando diseñamos
la función tenı́amos en mente que siempre usarı́amos un vector numéri-
co. Pero, al cabo del tiempo, cuando este recuerdo memorı́stico se nos
haya olvidado y pasemos como argumento un vector de caracteres, ¿fun-
cionará correctamente? Comprobémoslo:
> Fmedia(c(’buenas’, ’tardes’, ’alumnos’))

Error in sum(x) : ’type’ (character) de argumento no válido
3. En el caso de un vector de valores lógicos funciona correctamente ya que

son convertidos a números (FALSE = 0 y TRUE = 1)
> Fmedia(c(TRUE, TRUE, FALSE), dec = 3)

[1] 0.667
4. Supongamos que queremos calcular la media de un vector numérico, por

ejemplo del perı́metro de la cintura de los padres del ejemplo FAMILIAS,
¿funciona bien cuando hay algún dato ausente? Comprobémoslo:

> load(’df_familias.RData’)
> with(df_familias, Fmedia(waist))
[1] NA
Si hubiéramos programado adecuadamente, contemplando la posibilidad

de NA en el vector, no tendrı́amos ningún problema:
> #-----------------------------------------------------------
> # Fmedia() Calcula la media de un vector numérico
> #-----------------------------------------------------------
> Fmedia <- function(
+ x, # x debe ser un vector numérico
+ ) {
+ if (!is.numeric(x)) # parar si no es numérico
+ stop(’x debe ser un vector numérico’)
+
+ n <- length(x) # datos
+ sx <- sum(x) # suma de datos
+ m <- sx / n # media
+
+ # resultado
+ round(m, dec) # media redondeada
+ }
> #-----------------------------------------------fin Fmedia()
Comprobemos que ahora funciona bien:
> with(df_familias, Fmedia(waist))

[1] 62.662
Ası́ queda la función perfectamente programada y documentada. Además

funciona bien.
Pero, después de todo este trabajo, encontramos que R tiene un función que
hace esto (más) correctamente: la función mean(). Por lo tanto, hemos perdido
un tiempo precioso en algo que ya estaba programado. De aquı́ sacamos la
conclusión que antes de programar alguna función tenemos que ver si R ya la
tiene incorporada; si la tiene, nos ahorraremos dedicar un tiempo a ello, pero
si no la tiene, deberemos programarla, después de haber pensado bien qué es
lo que queremos hacer, cómo hacerlo y documentarlo adecuadamente.
26.2. Programando funciones no tan triviales

26.2.1. Tercera función: Fdescrip basica()
La mejor manera de aprender a programar es programando. Ahı́ es dónde
se encuentran las dificultades y el camino para superarlas. Cuanto más se pro-
grame más soltura se adquiere en el manejo de R. Por supuesto, ¡cuanto más
se programa, más satisfacción produce R!

26.2. PROGRAMANDO FUNCIONES NO TAN TRIVIALES 331
Suponga que desea programar una sencilla función que realice una estadı́sti-
ca descriptiva básica de un vector numérico; quiere que calcule el número de
www.editorialuc.es
datos válidos, la media, la desviación estándar y el número de datos ausentes
(NA o missing) existentes. Podrı́a hacer algo ası́:
> #-----------------------------------------------------------
> # Fdescrip_basica() Estadı́stica descriptiva básica de un
> # vector numérico
> #-----------------------------------------------------------
> Fdescrip_basica <- function(
+ x, # vector numárico
+ ) {
+ if (!is.numeric(x)) stop(’x debe ser un vector numérico’)
+
+ # cuerpo de la función (cálculos)
+ N <- length(x) # longitud del vector original
+ n <- length(x) # longitud del vector depurado
+ m <- mean(x) # media
+ s <- sd(x) # desviación estándar
+ res <- cbind(missing = N - n,
+ datos = n,
+ media = m,
+ DE = s)
+ rownames(res) <- ’Estadı́sticos’
+
+ # resultado
+ res
+ }
> #-------------------------------------fin Fdescrip_basica()
Ejemplo 26.1. Pruébela con los datos del peso, talla y perı́metro de la cintura
del ejemplo FAMILIAS.
Deberá tener en memoria la BdD df familias; si no la tiene léala con
load(’df familias.RData’).
> with(df_familias, Fdescrip_basica(weight))
missing datos media DE
Estadı́sticos 2 40 47.67 25.79964
> with(df_familias, Fdescrip_basica(height))
Estadı́sticos 3 39 143.3821 32.70267
> with(df_familias, Fdescrip_basica(waist))
Estadı́sticos 3 39 62.66154 15.54717
Ejemplo 26.2. ¿Hay algún dato ausente en las edades de lo miembros de

estas familias?
> with(df_familias, Fdescrip_basica(age))[, ’missing’]
[1] 2

26.2.2. Cuarta función: Ftabla diag()

Suponga que desea dividir una variable numérica por un determinado pun-
to de corte en dos categorı́as para crear con ella y con una variable cualitativa
binaria una tabla 2x2 en la que determinar la sensibilidad y la especificidad.
¿Cómo lo harı́a?.
> #-----------------------------------------------------------
> # Ftabla_diag() Sensibilidad y especificidad en tabla 2x2
> #-----------------------------------------------------------
> Ftabla_diag <- function(
+ var_n, # variable numérica
+ var_c, # variable cualitativa
+ pdc, # punto de corte (escalar) min-pdc-max
+ info = TRUE # si se desea más información (tabla)
+ ) {
+ # comprobar condiciones
+ if (!is.numeric(var_n))
+ stop(’var_n debe ser numérica’)
+ if (dim(table(var_c)) != 2)
+ stop(’var_c debe ser cualitativa’)
+ if (length(var_n) != length(var_c))
+ stop(’Las dos variables deben tener la misma longitud’)
+ if (length(pdc) > 1 | pdc < min(var_n) | pdc > max(var_n))
+ stop(’Punto de corte inadecuado’)
+
+ y <- cut(var_n, breaks = c(min(var_n), pdc, max(var_n)),
+ include.lowest = TRUE, right = FALSE)
+ M <- table(y, var_c) # se crea la tabla
+ sen <- M[2, 2] / sum(M[, 2]) # sensibilidad
+ esp <- M[1, 1] / sum(M[, 1]) # especificidad
+
+ if (info) {
+ cat(’\n Tabla 2x2:’, ’\n’)
+ print(addmargins(M))
+ cat(’\n’)
+ }
+
+ # resultado
+ res <- list(sen = sen, esp = esp)
+ res
+ }
> #----------------------------------------fin Ftabla_diag()
Ejemplo 26.3. Pruebe la función con los vectores x = rnorm(267) e y =

sample(0:1, size = 267, replace = TRUE).
Para evitar que usted pueda obtener un resultado diferente, porque la fun-
ción rnorm() ofrece resultados aleatorios cada vez que se ejecuta, hemos co-
menzado con la función set.seed(2016) que fija la semilla generadora de
los números aleatorios, por lo que deberá obtener el mismo resultado que en el
texto.
> set.seed(2016)

26.2. PROGRAMANDO FUNCIONES NO TAN TRIVIALES 333
> x <- rnorm(267)

> y <- sample(0:1, size = 267, replace = TRUE)
www.editorialuc.es
> Ftabla_diag(x, y, pdc = 0.43)
Tabla 2x2:
var_c
y 0 1 Sum
[-2.79,0.43) 80 97 177
[0.43,3.03] 43 47 90
Sum 123 144 267
$sen
[1] 0.3263889
$esp
[1] 0.6504065
> rm(x, y)
26.2.3. Quinta función: Fazar()

Suponga que desea programar una función que simule las extracciones al
azar (por ejemplo n tiradas de un dado) de un objeto que puede tener como
resultado un valor entre 1 y x (por ejemplo, entre 1 y 6 si es un dado de seis
caras).
> #----------------------------------------------------------
> # Fazar() Simulación aleatoria
> #----------------------------------------------------------
> Fazar <- function(
+ x, # número de tiradas
+ inf = 1, # valor mı́nimo (por defecto 1)
+ sup = 6, # valor máximo (por defecto 6)
+ graph = TRUE # si se desea un gráfico
+ ) {
+ # condiciones
+ if (!is.numeric(x))
+ stop(’x debe ser el número de lanzamientos’)
+ if (length(x) > 1) x <- x[1] # solo el primer dato
+ if (sup - inf < 1)
+ stop(’Valores mı́nimo y máximo mal declarados’)
+
+ # cálculos
+ k <- sample(inf:sup, size = x, replace = TRUE)
+ M <- table(k)
+ if (graph) barplot(M, col = rainbow(sup - inf + 1))
+
+ # resultados
+ res <- list(tiradas = x, limite_inf = inf,
+ limite_sup = sup, resultados = k,
+ media = mean(k), DE = sd(k), tabla = table(k))
+ res
+ }
> #-----------------------------------------------fin Fazar()

Ejemplo 26.4. Simule 200 tiradas de una dado.

Si simulamos 200 lanzamientos (tiradas = 200) de un dado clásico de 6
caras (inf = 1, sup = 6) veremos los resultados de los lanzamientos, la media
(tiende a (amplitud + 1)/2), la desviación estándar y una tabla resumen de los
resultados obtenidos. Además si queremos (por defecto, sı́) nos presenta un
gráfico de barras (Figura 26.1):
40
30
20
10
0
1 2 3 4 5 6
Figura 26.1: Gráfico de barras de la simulación de 200 lanzamientos de un dado de seis

caras.
> set.seed(2016)
> Fazar(200)
$tiradas
[1] 200
$limite_inf
[1] 1
$limite_sup
[1] 6
$resultados
[1] 2 1 6 1 3 1 4 6 1 1 3 2 2 6 2 3 4 1 4 1 2 5 3 4 6 4 2 4 6 3
[31] 4 5 2 6 6 1 2 2 2 5 3 1 2 5 3 2 5 2 4 3 1 3 2 3 6 3 6 1 1 3
[61] 1 4 3 2 6 6 1 1 4 6 6 6 2 5 2 1 2 6 1 1 3 1 5 5 3 2 2 4 5 4
[91] 3 5 1 5 6 1 5 4 1 3 3 2 2 2 1 4 1 4 4 1 1 5 6 6 1 4 3 2 3 6
[121] 5 6 5 4 2 4 2 1 5 4 6 5 3 1 1 3 3 3 5 2 5 1 4 3 1 1 3 4 3 4
[151] 5 5 4 3 5 4 3 3 3 1 5 3 5 5 5 2 2 1 1 1 6 4 2 2 5 4 3 4 4 2
[181] 6 4 5 6 1 4 5 1 3 4 2 1 4 3 3 6 1 5 6 4
$media
[1] 3.285
$DE
[1] 1.690581
$tabla
k
1 2 3 4 5 6
41 33 36 34 30 26

www.editorialuc.es
tablas:
Función Acción
addmargins() Añade márgenes a una tabla
cut() Categoriza una variable numérica
dim() Dimensiones de un objeto
f() ((f)) función de ejemplo
Fmedia() Función programada: media de un vector
Fdescrip basica() Función programada: descriptiva numérica
Fsaludos() Función programada: saludos
Ftabla diag() Función programada: tabla diagnóstica
if() Condición
is.character() Comprueba si es on objeto de tipo caracteres
is.numeric() Comprueba si es un vector numérico
max() Valor máximo
mean() Media de un vector numérico
min() Valor mı́nimo
paste() Une objetos y los imprime en la consola
print() Imprimir en consola
return() Devuelve un objeto de una función
rnorm() Vector de elementos que siguen una distribución normal
round() Función de redondeo
rownames() Da nombres a las filas de un objeto (o los lee)
sd() Calcula la desviación estándar de un vector numérico
sum() Suma de los elementos de un vector numérico
stop() Sale de una función
table() Crea una tabla de contingencia
toupper() Convierte una cadena a mayúsculas
with() Para acceder a las variables de una data frame

Función Acción
epicalc Funciones epidemiológicas con epicalc [136]
PROBLEMAS
Problema 1. Escriba una función que calcule la suma de los n primeros números
naturales.
Problema 2. Escriba una función que calcule
n
X
i2
i=1
Problema 3. Escriba una función que encuentre el valor mı́nimo de un vector em-
pleando un bucle y sin emplear las funciones min() ni sort().

www.editorialuc.es
Capı́tulo 27
Funciones de utilidad
27.1. Programando otras funciones con utilidad

Aquı́ vamos a ir programando las diferentes funciones que desarrollaremos
a lo largo del curso (Tabla 27.1).
Tabla 27.1: Funciones programadas por el usuario.
Rótulo1 Rótulo2
Fed n() Estadı́stica descriptiva de una variable numérica
Fnormalidad() Comprobación de la normalidad de una variable
Fh() Histograma mejorado
Fcomplete cases() Casos completos en un data frame
Fprueba diag() Caracterı́sticas de una prueba diagnóstica
27.1.1. Estad. descriptiva de una variable numérica: Fed n()

Anteriormente programamos Fdescrip basica() para obtener como re-
sultado el número de datos ausentes (missings), el número de datos válidos, la
media y la desviación estándar. Ahora pretendemos una función que ofrezca
más resultados como: quartiles, rango (mı́nimo y máximo), percentiles e, inclu-
so, unos gráficos que nos permitan valorar las caracterı́sticas de dicha variable.
#---------------------------------------------------------------
Fed_n(var1, dec = 2, graph = TRUE, pc = TRUE)
#---------------------------------------------------------------
> #----------------------------------------------------------
> # Fed_n() Estad. descriptiva de una variable numérica
> #----------------------------------------------------------
> Fed_n <- function(
+ x, # variable numérica
+ dec = 2, # número de decimales
337
338 CAPÍTULO 27. FUNCIONES DE UTILIDAD
+ graph = TRUE, # si se desea un gráfico

+ pc = TRUE # si se desean percentiles
+ ) {
+ if (!is.numeric(x))
+ stop(’Debe ser una variable numérica’)
+ N <- length(x) # longitud (con missing)
+ x <- x[!is.na(x)] # sin missing
+ n <- round(length(x), dec) # longitud (sin missing)
+ me <- round(mean(x), dec) # media
+ de <- round(sd(x), dec) # DE
+ m0 <- round(min(x), dec) # mı́nimo
+ m1 <- round(max(x), dec) # máximo
+ q1 <- round(quantile(x, .25), dec) # Q1
+ q2 <- round(median(x), dec) # Q2
+ q3 <- round(quantile(x, .75), dec) # Q3
+
+ cat(’\nEstadı́stica descriptiva numérica:’)
+ cat(’\n=================================\n’)
+
+ if (graph) {
+ old.par <- par(mfrow = c(2, 3))
+ hist(x, col = 5, main = ’Histogram’)
+ rug(x, col = 4); box()
+ plot(density(x), main = ’Densities’)
+ curve(dnorm(x), add = TRUE, lty = 2, col = 2)
+ plot(ecdf(x), main = ’CDF’)
+ curve(pnorm(x), add = TRUE, lty = 2, col = 2)
+ qqnorm(x); qqline(x, col = 2, lw = 1.3)
+ dotchart(sort(x), pch = 15, col = 3, main = ’DotChart’)
+ boxplot(x, col = 7, main = ’BoxPlot’, notch = TRUE)
+ points(me, col = 2, cex = 2, pch = 16)
+ points(mean(x, trim = .1), pch = 15)
+ mtext(’[red dot = mean]’, side = 1, line = 1, cex = .8)
+ par(old.par)
+ }
+ if (pc==TRUE) {
+ p3 <- round(quantile(x, .03), dec)
+ Mp <- cbind(P3 = p3, P5 = p5, P10 = p10, P25 = p25,
+ P50 = p50, P75 = p75, P85 = p85,
+ P90 = p90, P95 = p95, P97 = p97)
+ rownames(Mp) <- ’Percentiles ’
+ print(Mp)
+ cat(paste(rep(’-’, 60), sep = ’’, collapse = ’’), ’\n’)
+ }
+ M <- cbind(’NA’ = N - n, n = n, media = me,

27.1. PROGRAMANDO OTRAS FUNCIONES CON UTILIDAD 339
+ DE = de, mı́n = m0, Q1 = q1,

+ mediana = q2, Q3 = q3, máx = m1)
www.editorialuc.es
+ rownames(M) <- ’Estadı́sticos’
+ M
+ }
> #-----------------------------------------------fin Fed_n()
Ejemplo 27.1. Vamos a generar 1000 valores aleatorios que sigan una Ley
Normal (con media 80 y desviación estándar 9.52) y luego utilizaremos la
función Fed n() para realizar la estadı́stica descriptiva de dicha variable.
Histogram Densities CDF

100 150 200
0.04
0.8
Frequency
Density
Fn(x)
0.02
0.4
50
0.00
0.0
0
50 70 90 50 70 90 50 70 90
x N = 1000 Bandwidth = 2.152 x
Normal Q−Q Plot DotChart BoxPlot
●●
●
●
● ●
●●
●
●
100
100
●●
Sample Quantiles
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●●
●
●●
●
●●
●
●●
●
●
●
●
●
●
●
●
●
80
80
●
●
●
●
●●
●
●●
●
●
●
●
●
●
●
●
●●
●
●
●●
●
●
●
●
●
●
●
●●
●●
●
●
●
60
60
●
●
●
●●
●
●●
●● ●
●● ●
−3 −1 1 3 60 80 100 [red dot = mean]

Theoretical Quantiles
Figura 27.1: Gráfico con la función Fed n().
> set.seed(2016)
> x <- rnorm(1000, 80, 9.52)
> Fed_n(x)
Estadı́stica descriptiva numérica:

=================================
P3 P5 P10 P25 P50 P75 P85 P90 P95
Percentiles 62.5 64.11 67.64 73.29 80.58 86.53 89.83 91.86 95.5
P97
Percentiles 98.05

------------------------------------------------------------
NA n media DE mı́n Q1 mediana Q3 máx
Estadı́sticos 0 1000 80.07 9.52 52.33 73.29 80.58 86.53 110.16
27.1.2. Normalidad de una variable: Fnormalidad()

Una de las tareas que se deben hacer antes de analizar las variables numéri-
cas es comprobar su normalidad. Hay muchas pruebas [233–235]. Vamos a pro-
gramar una función que compruebe si una variable es normal (necesitaremos
tener instalado el paquete nortest).
#---------------------------------------------------------------
Fnormalidad(x, bw = 0.7, dec = 5, info = TRUE, graph = TRUE)
#---------------------------------------------------------------
El código de esta función es:
> #----------------------------------------------------------
> # Fnormalidad() Comprobación de la normalidad de una var
> #----------------------------------------------------------
> Fnormalidad <- function(
+ x, # variable numérica
+ bw = 0.7, # bandwidch
+ dec = 3, # decimales
+ info = TRUE, # si se desea información
+ ) {
+ # condiciones
+ if (!is.numeric(x)) stop(’La variable no es numérica’)
+ require(nortest)
+
+ # tests de normalidad
+ x <- x[!is.na(x)]
+ x1 <- ad.test(x)
+ x2 <- cvm.test(x)
+ x3 <- lillie.test(x)
+ x4 <- pearson.test(x)
+ x5 <- sf.test(x)
+ x6 <- shapiro.test(x)
+ x7 <- ks.test(x, ’pnorm’)
+ Statistic <- c(x1[1], x2[1], x3[1], x4[1],
+ x5[1], x6[1], x7[1])
+ Statistic <- round(unlist(Statistic), dec)
+ Pvalue <- unlist(c(x1[2], x2[2], x3[2], x4[2],
+ x5[2], x6[2], x7[2]))
+ # resultados
+ M <- data.frame(Statistic, round(Pvalue, dec))
+ rownames(M) <- c(’Anderson-Darling test’,
+ ’Cramer-von Mises test’,
+ ’Lilliefors (K-S) test’,
+ ’Pearson chisquare test’,
+ ’Shapiro-Francia test’,
+ ’SHAPIRO-WILK test =======>’,
+ ’Kolmogorov-Smirnov test’)

+ colnames(M) <- c(’statistic’, ’p.value’)

+ detach(package:nortest)
www.editorialuc.es
+
+ if (graph) {
+ old.par <- par(mfrow = c(1, 3))
+ qm <- max(density(x, bw = bw)$y)
+ hist(x, prob = TRUE, ylim = c(0, qm))
+ rug(x)
+ lines(density(x, bw = bw), lw = 2, col = ’red’)
+
+ boxplot(x, main = ’Boxplot’)
+ points(1, mean(x, trim = 0.1), pch=15,
+ cex = 2, col = ’green’)
+ points(1, mean(x), pch = 15, cex = 2, col = ’red’)
+ legend(’topleft’, legend = c(’mean’,’mean-10%’),
+ pch = 15, col = 2:3)
+
+ qqnorm(x)
+ qqline(x, lw = 2, col = ’red’)
+ par(old.par)
+ }
+
+ if (info) {
+ cat(’\nPRUEBA DE NORMALIDAD DE UNA VARIABLE’)
+ cat(’\n============================================’)
+ cat(’\nLa más potente y aconsejable es S-W’)
+ cat(’\n’)
+ cat(’\n’)
+ }
+ M
+ }
> #------------------------------------------fin Fnormalidad()
}
Ejemplo 27.2. En la BdD GAGurine del paquete MASS, compruebe si la va-

riable GAG sigue una distribución normal.
> with(MASS::GAGurine, Fnormalidad(GAG, bw=3))
Loading required package: nortest
PRUEBA DE NORMALIDAD DE UNA VARIABLE

============================================
La más potente y aconsejable es S-W
statistic p.value
Anderson-Darling test 10.396 0
Cramer-von Mises test 1.732 0
Lilliefors (K-S) test 0.124 0
Pearson chisquare test 125.618 0
Shapiro-Francia test 0.867 0
SHAPIRO-WILK test =======> 0.868 0
Kolmogorov-Smirnov test 0.973 0
Warning messages:
1: In cvm.test(x) :

p-value is smaller than 7.37e-10, cannot be computed more accurately

2: In ks.test(x, "pnorm") :
ties should not be present for the Kolmogorov-Smirnov test
Histogram of x Boxplot Normal Q−Q Plot

0.06
mean ●
● ●
●
mean−10%
50
50
0.05
● ●
● ●
40
40
0.04
● ●
● ●
● ●
●
● ●●
Sample Quantiles
● ●
●
●
●●
●
●
●
Density
0.03
●
●
30
30
●
●
●
●
●
●
●
●
●●
●
●
●●
●
●●
●
●
●
●
0.02
●●
●
20
20
●
●●
●●
●
●●
●
●
●
●●
●
●
●
●
●●
●
●●
●
●●
●
●●
●
●
●
●
●
●
●
●●
●●
0.01
●●
●
●●
●
●●
●
10
10
●●
●
●
●●
●
●
●●
●
●●
●
●●
●
●
●●
●
●
●
●
●
●●
●
●
●●
●●
●
●●
●
●
●
●
●●
●●
●
●●
●
●●
●●
●●
●
●●
●
●●
●●
●
●●
●
●
●●
●●
●●
●
0.00
●●●
● ● ●●●●●
0
0
0 10 20 30 40 50 60 −3 −2 −1 0 1 2 3
x Theoretical Quantiles
Figura 27.2: Gráfico con la función Fnormalidad().
En la Figura 27.2, además del resultado de la función Fnormalidad(), se

aprecia claramente que no sigue una distribución normal.
En la salida de la función se ofrecen varios tests, el más importante es el de
Shapiro-Wilk, por eso se destaca en mayúsculas y con una flecha. Todos ellos
da un resultado significativo (p < 0,05), indicando que la variable estudiada se
aleja de una distribución normal.
27.1.3. Histograma mejorado: Fh()

Cuando queremos representar gráficamente una variable numérica recu-
rrimos a un histograma. De él hablaremos más adelantePodemos adelantar
que habitualmente utiliza la regla de Sturges [236] para construir los intervalos
(Intervalos = dlog2 n + 1e), pero con un simple histograma es difı́cil valorar la
normalidad de una variable, ya que dependiendo del número de intervalos la
información que ofrece la imagen del histograma puede variar.
Aquı́ desarrollamos un ((histograma mejorado)), en el que, además de su-
perponer la curva normal generada con los propios datos y la curva de densi-
dad, presentamos una prueba de normalidad (la más potente es la de Shapiro-
Wilk) y unas etiquetas con la media y desviación estándar si la variable es nor-
mal o la mediana y el rango intercuartı́lico si no lo es.
Los argumentos son:
#---------------------------------------------------------------
Fh(
x, # variable cuantitativa
xlab = ’’, # etiqueta variable cuantitativa
ylab = ’Density’, # etiqueta eje de ordenadas
main = ’’, # tı́tulo del gráfico
valores = TRUE, # si se desea una etiqueta
curvaN = TRUE, # si se desea sobreimponer la curva normal

curvaD = TRUE, # si se desea la curva de densidad

dec = 1, # decimales para media y DE
www.editorialuc.es
... # otros parámetros extra
)
#---------------------------------------------------------------
Su código es el siguiente:
> #----------------------------------------------------------
> # Fh() Construye un histograma ((mejorado))
> #----------------------------------------------------------
> Fh <- function(
+ x, # variable cuantitativa
+ xlab = ’’, # etiqueta variable cuantitativa
+ ylab = ’Density’, # etiqueta eje de ordenadas
+ main = ’’, # tı́tulo del gráfico
+ valores = TRUE, # si se desea una etiqueta
+ curvaN = TRUE, # si se desea sobreimponer la curva normal
+ curvaD = TRUE, # si se desea la curva de densidad
+ dec = 1, # decimales para media y DE
+ ... # otros parámetros extra
+ ) {
+
+ if(!is.numeric(x)) stop(’La variable debe ser numérica’)
+
+ x <- x[!is.na(x)]
+ qm <- max(density(x)$y)
+ hist(x, xlab = xlab, main = ’’, freq = FALSE,
+ col = ’grey90’, las = 1, ylab = ylab,
+ cex.lab = .9, col.lab = 4, font.lab = 2,
+ ylim = c(0, qm), cex.axis = .8, ...)
+ A <- shapiro.test(x)
+
+ if (valores) {
+ if (A$p.value <= 0.05) {
+ legend(’topright’,
+ legend = c(paste(’Median =’,
+ round(median(x), dec)),
+ paste(’ IQR =’,
+ round(IQR(x), dec + 1))))
+ } else {
+ legend(’topright’,
+ legend=c(paste(’Mean =’,
+ round(mean(x), dec)),
+ paste(’ SD =’,
+ round(sd(x), dec + 1))))
+ }
+ }
+ rug(x, col = 4, ticksize = 0.02)
+
+ if (curvaN) {
+ mu <- mean(x)
+ sigma <- sqrt(sum((x - mu) ˆ 2) / length(x))
+ z <- seq(min(x), max(x), length = 300)
+ lines(z, dnorm(z, mu, sigma), col = 2, lt = 1)

+ }
+
+ if (curvaD) {
+ lines(density(x), col = 3)
+ }
+
+ if (curvaN & curvaD) {
+ Z <- numeric()
+ Z <- locator(1)
+ if(length(Z) == 2) {
+ legend(Z$x, Z$y,
+ legend = c(’normal’, ’density’),
+ lt = 1, col = 2:3, bty = ’n’)
+ }
+ }
+ B <- ifelse(A$p.value < 0.001, ’p < 0.001’,
+ paste(’p =’,round(A$p.value,3)))
+ cadena <- paste(’Shapiro-Wilk (’, B, ’)’, sep = ’’)
+ mtext(cadena, side = 1, line = 4, font = 3,
+ adj = 0, cex = 0.8)
+ }
> #--------------------------------------------------fin Fh()
Esta función permite crear un histograma y superponer la curvas de densi-

dad, la curva normal, ambas o ninguna. El parámetro ... permite que poda-
mos ajustar otros parámetros gráficos.
Ejemplo 27.3. Realice un histograma mejorado de la variable tad de la BdD

de las indias Pima.
> load(’bd_pima.RData’)
> epicalc::use(.data)
> opar <- par(mfrow = c(1,2))
> hist(tad, main=’’)
> Fh(tad)
Es evidente que la mejorı́a es manifiesta. La distribución de la TAD parece

moral en el histograma, pero con la función Fh() se comprueba que no sigue
una ley normal, aunque la curve de densidad se aproxima a la normal.
27.1.4. Calidad de una base de datos: Fcomplete cases()

Esta función, que ya utilizamos previamente, tiene como finalidad poner en
evidencia los missings que existen en una BdD, el porcentaje que representan y
el porcentaje de casos sin ningún missing.
Cuando se va a analizar una BdD es importante conocer cuántos missings
hay, porque si existen muchas variables con datos ausentes es posible que para
el análisis multivariable queden muy pocos casos y la muestra no sea represen-
tativa, de manera que las conclusiones pueden no ser válidas.
#---------------------------------------------------------------
Fcomplete_cases(df, info = TRUE, graph = TRUE)
#---------------------------------------------------------------

www.editorialuc.es
Median = 72
0.030 IQR = 16
150
0.025
Frequency
0.020
Density
100
0.015
0.010
50
0.005
0.000
0
20 40 60 80 100 120 20 40 60 80 100 120
tad
Shapiro−Wilk (p < 0.001)
Figura 27.3: Histograma de la variable Glup. A la izquierda el histograma que realiza

R por defecto; a la derecha el histograma mejorado con nuestra función Fh().
> #----------------------------------------------------------
> # Fcomplete_cases() Calidad de una BdD
> #----------------------------------------------------------
> Fcomplete_cases <- function(
+ df, # el data frame que se va a analizar
+ info = TRUE, # si devuelve información
+ ) {
+ # condiciones
+ if(!is.data.frame(df)) stop(’df no es un data frame’)
+
+ # cálculos
+ nt <- dim(df)[1] # número total de casos
+ nc <- dim(df[complete.cases(df), ])[1] # casos completos
+ n3 <- sum(is.na(df)) # número total de NA
+ n4 <- nt * dim(df)[2] # número total de datos
+ (nVar <- dim(df)[2]) # número de variables
+ nMis <- numeric(nVar) # número de missings en cada variable
+ Names <- paste(’v’, 1:nVar, sep = ’’) # nombre variables
+ names(nMis) <- Names # para la representación gráfica
+ for (i in 1:nVar) { # se calculan los missings en
+ nMis[i] <- sum(is.na(df[,i])) # cada una de las variables
+ }
+
+ # gráfico
+ if (graph) { # se pinta un gráfico de barras con los
+ y <- barplot(nMis, col = rainbow(nVar), # missings de
+ main = ’Missings’, las = 1, # cada variable
+ ylim = c(0, max(nMis) * 1.1))
+ text(y, nMis, nMis, pos = 3, cex = 0.8) # núm. over bars
+ }
+ x1 <- paste(’(’, round(nc * 100 / nt), ’ %)’, sep = ’’)
+ x2 <- paste(’(’, round((n4 - n3) * 100 / n4), ’ %)’, sep=’’)

+
+ if (info) {
+ cat(’\n=====================================’)
+ cat(’\n Calidad de la Base de Datos’)
+ cat(’\n=====================================’)
+ cat(’\n’)
+ cat(’\nCasos totales............:’, nt)
+ cat(’\nCasos con missings.......:’, nt - nc)
+ cat(’\nCasos completos..........:’, nc, x1)
+ cat(’\n’)
+ cat(’\nDatos totales............:’, n4)
+ cat(’\nMissings.................:’, n3)
+ cat(’\nDatos evaluables.........:’, n4 - n3, x2)
+ cat(’\n’)
+ cat(’\nMissings en cada variable:’, nMis)
+ cat(’\n’)
+ cat(’\n’)
+ }
+ res <- df[complete.cases(df), ] # devuelve la BdD
+ invisible(res) # sin missings
+ }
> #-------------------------------------fin Fcomplete_cases()
Ejemplo 27.4. Calcule la calidad de la BdD de las familias ((df familias)).
Missings
3 3
3.0
2.5
2 2
2.0
1.5
1
1.0
0.5
0 0 0 0 0
0.0
v1 v2 v3 v4 v5 v6 v7 v8 v9 v10
Figura 27.4: Gráfico con la función Fcomplete cases() demostrando en número

de datos ausentes en cada una de las variables de la BdD de las familias.
> load(’df_familias.Rdata’)
> Fcomplete_cases(df_familias)
=====================================
Calidad de la Base de Datos
=====================================

Casos totales............: 42
Casos con missings.......: 4
www.editorialuc.es
Casos completos..........: 38 (90 %)
Datos totales............: 420

Missings.................: 11
Datos evaluables.........: 409 (97 %)
Missings en cada variable: 0 0 0 1 2 0 0 2 3 3
Se aprecia que de los 42 casos solo 38 están completos (90 %) y que hay
missings en cinco variables.
27.1.5. Pruebas diagnósticas: Fprueba diag()

Las pruebas diagnósticas tienen un importante papel en Medicina, por lo
que es fundamental conocer las principales caracterı́sticas de las mismas: sen-
sibilidad, especificidad, etc. Para ello necesitamos programar la siguiente fun-
ción.
#---------------------------------------------------------------
Fprueba_diag(a11, a21, a12, a22, alpha = 0.05, d = 3)
#---------------------------------------------------------------
> #----------------------------------------------------------
> # Fprueba_diag() Caracterı́sticas de una prueba diagnóstica
> #----------------------------------------------------------
> Fprueba_diag <- function(
+ a11, # Prueba (+) en sanos
+ a21, # Prueba (-) en sanos
+ a12, # Prueba (+) en enfermos
+ a22, # Prueba (-) en enfermos
+ alpha = 0.05, # riesgo alfa
+ ) {
+
+ # condiciones
+ if (!is.numeric(c(a11, a21, a12, a22)))
+ stop(’Debe introducir cuatro valores numéricos’)
+ if (length(a11) > 1 | length(a12) > 1 |
+ length(a21) > 1 | length(a22) > 1)
+ stop(’Solo se admiten 4 escalares’)
+
+ # cálculos
+ require(Hmisc)
+ M <- matrix(c(a11, a21, a12, a22), nr = 2)
+ dimnames(M) <- list(c(’Prueba +’, ’Prueba -’),
+ c(’ Verdad -’, ’ Verdad +’))
+ n <- sum(M) # número de sujetos estudiados
+ M1 <- M / n # matriz de proporciones
+
+ # sensibilidad

+ S <- a12 / (a12 + a22)

+ Si <- binconf(a12, a12 + a22)[2]
+ Ss <- binconf(a12, a12 + a22)[3]
+
+ # especificidad
+ E <- a21 / (a11 + a21)
+ Ei <- binconf(a21, a11 + a21)[2]
+ Es <- binconf(a21, a11 + a21)[3]
+
+ # prevalencia
+ P <- (a12 + a22) / n
+ Pi <- binconf(a12 + a22, n)[2]
+ Ps <- binconf(a12 + a22, n)[3]
+
+ # eficiencia global
+ eff <- (a21 + a12) / n
+ effi <- binconf(a21 + a12, n)[2]
+ effs <- binconf(a21 + a12, n)[3]
+
+ # valor predictivo positivo
+ vpp <- a12 / (a11 + a12)
+ vppi <- binconf(a12, a11 + a12)[2]
+ vpps <- binconf(a12, a11 + a12)[3]
+
+ # valor predictivo negativo
+ vpn <- a21 / (a21 + a22)
+ vpni <- binconf(a21, a21 + a22)[2]
+ vpns <- binconf(a21, a21 + a22)[3]
+
+ # falsos positivos
+ fp <- a11 / (a11 + a21)
+ fpi <- binconf(a11, a11 + a21)[2]
+ fps <- binconf(a11, a11 + a21)[3]
+
+ # falsos negativos
+ fn <- a22 / (a12 + a22)
+ fni <- binconf(a22, a12 + a22)[2]
+ fns <- binconf(a22, a12 + a22)[3]
+
+ # likelihood ratio
+ lrp <- S / (1 - E) # LR+
+ lrn <- (1 - S) / E # LR-
+ if (lrp < 2) slrp <- ’Pobre’
+ else if (lrp < 5) slrp <- ’Regular’
+ else if (lrp < 10) slrp <- ’Buena’
+ else slrp <- ’Excelente’
+ slrp <- paste(slrp,
+ ’contribución de una prueba (+) al diag(enf)’)
+ if (lrn > 0.5) slrn <- ’Pobre’
+ else if (lrn > 0.2) slrn <- ’Regular’
+ else if (lrn > 0.1) slrn <- ’Buena’
+ else slrn <- ’Excelente’
+ slrn <- paste(slrn,
+ ’contribución de una prueba (-) al diag(sano)’)

+
+ # Odds pretest
www.editorialuc.es
+ opt <- (P / (1 - P)) * (S / (1 - E))
+
+ # odds ratio
+ or <- (a12 * a21) / (a11 * a22)
+ se_or <- sqrt(1 / a11 + 1 / a12 + 1 / a21 + 1 / a22)
+ ori <- or * exp(-qnorm(1 - alpha / 2) * se_or)
+ ors <- or * exp(+qnorm(1 - alpha / 2) * se_or)
+
+ # para redondear
+ r <- function(x, dec = 3) round(x, dec)
+
+ cat(’\nTabla de datos\n’)
+ print(addmargins(M))
+ cat(’\nTabla de probabilidades\n’)
+ print(addmargins(M1))
+ cat(’\n1. Enfermedad’)
+ cat(’\n Prevalencia.................’, r(P, dec),
+ ’ IC-95%:’, r(Pi, dec), ’a’, r(Ps, dec))
+ cat(’\n2. Caracterı́sticas de la prueba’)
+ cat(’\n Validez interna’)
+ cat(’\n Sensibilidad (1-beta).......’, r(S, dec),
+ ’ IC-95%:’, r(Si, dec), ’a’, r(Ss, dec))
+ cat(’\n Especificidad (1-alfa)......’, r(E, dec),
+ ’ IC-95%:’, r(Ei, dec), ’a’, r(Es, dec))
+ cat(’\n Otras’)
+ cat(’\n Falsos positivos (alfa).....’, r(fp, dec),
+ ’ IC-95%:’, r(fpi, dec), ’a’, r(fps, dec))
+ cat(’\n Falsos negativos (beta).....’, r(fn, dec),
+ ’ IC-95%:’, r(fni, dec), ’a’, r(fns, dec))
+ cat(’\n Eficiencia global...........’, r(eff, dec),
+ ’ IC-95%:’, r(effi, dec), ’a’, r(effs, dec))
+ cat(’\n Índice de Youden............’,
+ r(S + E - 1, dec))
+ cat(’\n3. Razones de verosimilitud’)
+ cat(’\n LR+ ........................’,
+ r(lrp, dec), ’ ’, slrp)
+ cat(’\n LR- ........................’,
+ r(lrn, dec), ’ ’, slrn)
+ cat(’\n4. Valores predictivos’)
+ cat(’\n VP+ ........................’, r(vpp, dec),
+ ’ IC-95%:’, r(vppi, dec), ’a’, r(vpps, dec))
+ cat(’\n VP- ........................’, r(vpn, dec),
+ ’ IC-95%:’, r(vpni, dec), ’a’, r(vpns, dec))
+ cat(’\n5. Odds’)
+ cat(’\n Odds pre-test...............’,
+ r(P / (1 - P), dec))
+ cat(’\n Odds post-test..............’, r(opt, dec))
+ cat(’\n Probabilidad post-test......’,
+ r(opt / (opt + 1)))
+ cat(’\n Odds ratio (OR).............’, r(or, dec),
+ ’ IC-95%:’, r(ori, dec), ’a’, r(ors, dec))
+ cat(’\n\n’)

+
+ # resultado
+ res <- list(SEN = S, ESP = E, FP = fp, FN = fn,
+ PRE = P, EFI = eff, VPP = vpp, VPN = vpn,
+ LRP = lrp, LRN = lrn, OPT = opt, OR = or)
+ invisible(res)
+ }
> #-------------------------------------fin Fprueba_diag()
Ejemplo 27.5. En niños diagnosticados clı́nicamente de faringitis aguda fe-

bril se realizó una prueba rápida y un cultivo (considerado el patrón oro). De
los 109 con prueba rápida positiva se confirmaron 91 y de los 343 resultados
negativos se confirmaron 319. Describa las caracterı́sticas de la prueba rápi-
da para el diagnóstico de la faringitis aguda por estreptococo β-hemolı́tico
del grupo A.
> Fprueba_diag(18, 319, 91, 24)
Tabla de datos
Verdad - Verdad + Sum
Prueba + 18 91 109
Prueba - 319 24 343
Sum 337 115 452
Tabla de probabilidades
Verdad - Verdad + Sum
Prueba + 0.03982301 0.20132743 0.2411504
Prueba - 0.70575221 0.05309735 0.7588496
Sum 0.74557522 0.25442478 1.0000000
1. Enfermedad
Prevalencia................. 0.254 IC-95%: 0.216 a 0.297
2. Caracterı́sticas de la prueba
Validez interna
Sensibilidad (1-beta)....... 0.791 IC-95%: 0.708 a 0.856
Especificidad (1-alfa)...... 0.947 IC-95%: 0.917 a 0.966
Otras
Falsos positivos (alfa)..... 0.053 IC-95%: 0.034 a 0.083
Falsos negativos (beta)..... 0.209 IC-95%: 0.144 a 0.292
Eficiencia global........... 0.907 IC-95%: 0.877 a 0.931
Índice de Youden............ 0.738
3. Razones de verosimilitud
LR+ ........................ 14.815 Excelente contribución de una prueba (+) al diag(enf)
LR- ........................ 0.22 Regular contribución de una prueba (-) al diag(sano)
4. Valores predictivos
VP+ ........................ 0.835 IC-95%: 0.754 a 0.893
VP- ........................ 0.93 IC-95%: 0.898 a 0.953
5. Odds
Odds pre-test............... 0.341
Odds post-test.............. 5.056
Probabilidad post-test...... 0.835
Odds ratio (OR)............. 67.197 IC-95%: 34.939 a 129.236

tablas:

www.editorialuc.es
Función Acción
ad.test() Test de Anderson-Darling
addmargins() Añade totales a una tabla o matriz
binconf() IC-95 % de una proporción (Hmisc)
boxplot() Gráfico de cajas
c() Concatena elementos en un vector
cat() concatena e imprime
cbind() Crea una matriz con vectores columna
colnames() Pone nombres a las columnas de un dataframe
completre.cases() Selecciona casos sin missings
curve() Dibuja una curva
cvm.test() Test de Cramer-von-Mises
data.frame() Crea un data frame
density() Calcula la densidad de un histograma
detach() libera una BdD del entorno de trabajo
dnorm() Calcula la función de densidad normal
dotchart() Gráfico de puntos
Fcomplete cases() Calcula la calidad de una BdD
Fed n() Estadı́stica descriptiva de una variable numérica
Fh() Histograma mejorado
Fnormalidad() Comprueba la normalidad de una variable
Fprueba diag() Caracterı́sticas de una prueba diagnóstica
invisible() No imprime el resultado
is.numeric() Comprueba si un vector es numérico
ks.test() Test de Kolmogorov-Smirnov
lillie.test() Test de Lilliefors
lines() Dibuja un alı́nea
media() Media de un vector (no usar)
mtext() Escribe texto en un margen del gráfico
numeric() Crea un vector numérico
par() Fija parámetros gráficos
paste() Pega distintos objetos en uno solo
pearson.test() Test de normalidad de Pearson
points() Dibuja puntos
print() Imprime en consola
qqnorm() Función ((quantile))
qqline() Dibuja una lı́nea de normalidad
quantile() Calcula percentiles
rnorm() Números aleatorios según Ley Normal

Función Acción
round() Redondea a determinados decimales
rownames() Poner nombres por filas
sd() Desviación estándar
set.seed() Fija una semilla de aleatorización
shapiro.test() Test de Shapiro-Wilk
sqrt() Raı́z cuadrada
stop() Escribe un mensaje de parada de una función
text() Escribe texto en unas coordenadas
toupper() Pasa su argumento a mayúsculas
use() Utilizar una BdD
wilcox.test() Test de Wilcoxon
Función Acción
nortes Comprobación de la normalidad con nortes [136]
PROBLEMAS
Problema 1. Modifique la función FdesBasica() para que calcule también el
valor mı́nimo, el máximo, el percentil 25, la mediana y el percentil 75.
Problema 2. Escriba una función que calcule una tabla de frecuencias.

www.editorialuc.es
Capı́tulo 28
Depuración de errores
Casi todos los programas contienen errores que hay que buscar y depurar.
La depuración de errores es más un arte que una ciencia [146]. El principio
de la confirmación es la esencia del depurado [237], consistente es comprobar
que lo que cree que es cierto verdaderamente es cierto. Es importante que la
programación sea modular para que el depurado sea más fácil.
28.1. Depuración de errores

Cuando algo falla al ejecutar una función es deseable investigar por qué ha
sucedido y cuál es el estado de las variables cuando ocurrió el error. Para ello
R proporciona algunas herramientas (Tabla 28.1) [151].
Tabla 28.1: Funciones para la depuración de errores en R.
Función Acción
print() cat() Imprime el contenido de una variable
debug() Llama al browser para ver el contenido de una variable
browser() Interrumpe la acción de una función para que sea ins-
peccionado el contenido de una variable
traceback() Imprime las llamadas a distintas funciones hasta que
surge el error
28.1.1. La función debug()

Cuando una función f() devuelve un valor inesperado puede utilizar la
función debug().
#---------------------------------------------------------------
debug(fun, text = "", condition = NULL)
#---------------------------------------------------------------
353
354 CAPÍTULO 28. DEPURACIÓN DE ERRORES
Ejemplo 28.1. Cree una función que calcule el doble y el logaritmo de un

número.
+ # validación de argumento
+ if (!is.numeric(x)) stop(’x no es un número’)
+
+ # cálculos
+ # esta función calcula el doble de un número
+ # por error tecleó ((**)) en vez de ((*))
+ res <- cbind(número = x, doble = x**2, logaritmo = log(x))
+ rownames(res) <- ’’
+ res
+ }
La función f() recibe como argumento un número (x) y calcula su doble y

su logaritmo. Durante la programación del script tecleamos, sin darnos cuenta,
((**)) en vez de un ((*)).
Ejemplo 28.2. Compruebe que la función f() funciona bien con x = 2.
> f(2) # funciona bien, se espera un 4

número doble logaritmo
2 4 0.6931472
¡Perfecto!, parece que hemos escrito una buena función.
Ejemplo 28.3. Pruebe la función f() con x = 7.

> f(7)
7 49 1.94591
> # ¡error!, se esperaba que el doble de 7 fuera 14
Ante este resultado inesperado vamos a intentar la depuración con debug():
Ejemplo 28.4. Depure esta función con debug().

> debug(f)
> f(7)
debugging in: f(7)
debug en #1: {
if (!is.numeric(x))
stop("x no es un número")
res <- cbind(número = x, doble = xˆ2, logaritmo = log(x))
rownames(res) <- ""
res
}
Browse[2]> c
exiting from: f(7)
7 49 1.94591
Se aprecia que Rcuando presenta el código de la función pone que x se

eleva al cuadrado en vez de multiplicarse por 2. ¡Ahı́ está el error! La función
debug() nos ha permitido encontrar el error que ahora podemos corregir.

28.2. DEPURACIÓN EN EL ENTORNO DE RSTUDIO 355
28.1.2. La función traceback()
www.editorialuc.es
La función traceback() permite visualizar en qué punto de la función ha
ocurrido el error.
#---------------------------------------------------------------
traceback(x = NULL, max.lines = getOption("deparse.max.lines"))
#---------------------------------------------------------------
Ejemplo 28.5. Supongamos que tenemos una función que utiliza un argu-
mento que no existe....

+ cat(’\nLa función f() empieza bien’) # imprime mensaje
+ g(x) # llama a la función g() con x
+ cat(’\nLa función g() termina bien’)
+ }
>
> g <- function(x) {
+ x + variable_inexistente
+ }
Cuando se ejecuta la función f() surge el error:
> f(10) # cuando se ejecuta f()...
La función f() empieza bien

Error in g(x) : objeto ’variable_inexistente’ no encontrado
Se debe ejecutar la función traceback() y se detiene en g(x), por lo que

tecleando g se presenta el código de la función que da el error:
> traceback()
2: g(x) at #3
1: f(10)
> g
function(x) {
x + variable_inexistente
}
Ahı́ está el error; tras un examen cuidadoso, se corrige y se elimina el error.
28.2. Depuración en el entorno de RStudio

Una de las ventaja de RStudio es que en la ventana Environment cons-
tantemente se ven los valores que tienen las distintas variables que se están
manejando [118]. Esto ayuda muchı́simo en la depuración y evita la tediosa
tarea de imprimir los valores de las variables en un punto determinado del
programa.

356 CAPÍTULO 28. DEPURACIÓN DE ERRORES

tablas:
Función Acción
cbind() Junta objetos por columnas
debug() Inicia el depurador
is.numeric() Comprueba si un objeto es numérico
rownames() Asigna nombres por columnas
traceback() Ejecuta hasta el error
Función Acción
debug Paquete de ayuda a la depuración [238]

PROBLEMAS
www.editorialuc.es
Problema 1. Con la BdD de las indias pima intenta el siguiente modelo de re-
gresión: lm(emb ˜ edad + diab + tad + ptri + sexo). Si hay algún
error, compruebe cada una de las variables hasta encontrar quién causa ese error. De-
pure el modelo.

www.editorialuc.es
Capı́tulo 29
Programación orientada a
objetos
29.1. Concepto
R es un lenguaje de programación orientado a objetos u Object-Oriented Pro-
gramming (OOP) [114, 239, 240]. Se trata de un tipo especial de programación
en la que el programador define, respecto de una estructura de datos, no sólo
los tipos de datos, sino también los tipos de operaciones que pueden aplicarse
a esta estructura u objeto, que consta, por tanto, de datos, funciones y de las
relaciones que puede establecer con otros objetos. Por ejemplo, unos objetos
pueden heredar unas caracterı́sticas de otros objetos.
La principal ventaja de la OOP, una vez aprendida, es la gran facilidad de
mantenimiento de los programas, porque es fácil crear objetos que hereden ca-
racterı́sticas de otros sin tener que volver a programarlos. Pero para ello se ne-
cesita utilizar un lenguaje de programación OOP como pueden ser Java, C++,
Smalltalk. R también es un lenguaje OOP.
29.2. Antecedentes
La OOP nació en 1967 de la mano del lenguaje Simula 67, diseñado por Ole-
Johan Dhal y Kristen Nygaard en el Norwegian Computing Center en Oslo
[241] para hacer simulaciones de seguridad en aviones. Simula 67 ha tenido
una influencia importante en otros lenguajes de programación más modernos,
como por ejemplo en C++ y en Java.
El siguiente gran paso en la historia de la OOP, y el que verdaderamente le
dio categorı́a de paradigma con caracterı́sticas propias, fue el lenguaje Small-
talk, creado por Alan Kay (Figura 29.1), del Centro de Investigación en Palo
Alto de Xerox Corporation [242].
Hijo de un fisiólogo y una música, Kay se dedicó a los ordenadores de un
modo fortuito, ya que tras estudiar matemáticas y biologı́a en la Universidad
de Utah (EE. UU.) y dedicarse a la música, acabó en las Fuerzas Aéreas, donde
aprendió a programar. En 1967 realizando su doctorado [243] contactó con el
lenguaje de programación Simula del que tomó la idea de objeto, a la vez co-
359
360 CAPÍTULO 29. PROGRAMACIÓN ORIENTADA A OBJETOS
Figura 29.1: Dr. Alan Curtis Kay, el ((padre)) de la OOP.
mo un ente autocontenido dotado de unos comportamientos especı́ficos y de

un estado privado y como un ejemplar o concreción de una clase de objetos.
Para explicar la noción de objeto utiliza el sı́mil de una célula que intercambia
señales con su entorno y cuya membrana le protege de dicho entorno. Al igual
que todas las células comparten unos comportamientos básicos pero también
pueden tener comportamientos especı́ficos que diferencian a unas de otras; una
clase de objetos define los comportamientos comunes y puede especializarse en
distintas subclases que describen, cada una, los comportamientos añadidos.
Su tesis doctoral, titulada ((La máquina reactiva)), versaba sobre su visión de
un computador personal, del tamaño de un portátil actual, dotado de potentes
gráficos interactivos para comunicarse con el usuario, en una época en que las
capacidades de las máquinas eran muy limitadas y sus volúmenes inmensos.
Marchó a California, pasó dos años en la Universidad de Stanford traba-
jando en proyectos de inteligencia artificial, y entró después en el laboratorio
Palo Alto Research Center de Xerox Corporation, donde completó la primera
versión de Smalltalk en 1971.
Guiado por el objetivo de que la interfaz fuera lo más intuitiva posible,
ideó representaciones gráficas para muchos de los objetos. Para él ((todo)) eran
objetos. Ası́, los ficheros, los documentos, los periféricos, etc. tenı́an una repre-
sentación en la pantalla en forma de iconos gráficos. Las pantallas limitadas
a caracteres eran insuficientes para su propósito. Dotó a sus computadores de
pantallas gráficas basadas en pı́xeles y dedicó un procesador exclusivamente a
la tarea de gobernar los gráficos de la pantalla. Los convenios actuales de ven-
tanas solapadas que pueden desplazarse, ampliarse, minimizarse, etc. son obra
suya y de su equipo. Crearon ası́ un ((lenguaje)) muy intuitivo de convenciones
gráficas para comunicarse con el ordenador [244]. Ası́, no solo alumbraron un
nuevo paradigma de programación, sino que fueron los padres de los nume-
rosos sistemas operativos basados en ventanas gráficas e iconos que hicieron
furor a partir de 1985.
Sus superiores de Xerox no supieron ver la revolución que suponı́a este ti-
po de sistemas y no apoyaron sus trabajos adecuadamente. Parte de su equipo,
y más tarde él mismo, se marcharon a la empresa Apple, entonces incipien-
te, y aplicaron sus ideas al desarrollo de los primeros ordenadores personales
Macintosh [245].

29.3. CLASES 361
29.3. Clases
www.editorialuc.es
Una clase es una definición general de un objeto, posee un nombre, un con-
junto de atributos y un conjunto de funciones y procedimientos (métodos).
29.4. Objetos
Un objeto es una instancia concreta de una clase.
Está definido por: (1) los datos concretos que contiene, (2) por los métodos
que pueden operar sobre él, y (3) por el nombre identificador.
29.5. Caracterı́sticas de la OOP

La programación orientada a objetos (Object-Oriented-Programming, OOP)
es un estilo de programación que simplifica muchos problemas [150], ya que
hace que la programación sea mucho más clara y el código más reutilizable
[146].
Las principales caracterı́sticas de la OOP son: (1) Abstracción, el propio ob-
jeto indica cómo trabajará, (2) Encapsulación y ocultación, (3) Polimorfismo, de
forma que distintos objetos con distintos comportamientos pueden compartir
el mismo nombre, pero no hay problemas de confusión porque en el tiempo de
ejecución se asignan dinámicamente.
29.5.1. Ventajas de la OOP

La OOP tiene una serie de ventajas sobre otro tipo de programación, tales
como:
(1) Uniformidad, de manera que la representación de los objetos lleva implica
tanto el análisis como el diseño y la codificación de los mismos.
(2) Comprensión, porque los datos y los procedimientos de los objetos están
agrupados en clases.
(3) Flexibilidad, puesto que al tener relacionados los procedimientos con
los datos de los objetos cualquier cambio que se realice quedará reflejado au-
tomáticamente en cualquier lugar donde se usen los objetos.
(4) Estabilidad, ya que diferencia perfectamente los datos fijos de los que
pueden cambiar a lo largo del programa.
(5) Reusabilidad, ya que una vez definidos los objetos se pueden reutilizar en
otros programa que traten las mismas estructuras de información, de manera
que el desarrollo de un programa puede llegar a ser una simple combinación
de objetos ya definidos previamente.
29.6. Tipos de OOP

Hay dos estilos: uno antiguo (S3) y otro más moderno (S4).

29.6.1. Clase S3
La clase S3 (old-style S3) es el primero que se desarrolló, puesto fue intro-
ducido en 1990 como un simple mecanismo de clase/método y desde entonces
es conocido como S3 classes and methods [161]. Es el más utilizado en programa-
ción en R.
Es muy fácil de implementar ya que una clase es simplemente una lista con
el atributo class y con la capacidad de usar funciones genéricas (plot(),
print(), summary() y muchas otras) [146].
La mayor parte de los modelos estadı́sticos del paquete stats utilizan cla-
ses S3. Pese a su popularidad, no son muy adecuadas1 y son propensas a erro-
res. Estudie el siguiente código:
Ejemplo 29.1. Comprobación de la propensión a cometer errores con las

clases S3.
> x <- 1:20 # objeto: vector numérico

> class(x) # clase: integer
[1] "integer"
>
> lm1 <- lm(x ˜ runif(20)) # objeto: regresión lineal
> class(lm1) # clase: lm
[1] "lm"
>
> class(x) <- ’lm’ # se cambia la clase a x
> class(x) # clase: ahora es lm (no integer)
[1] "lm"
> plot(lm) # la función genérica da error
Error in formula.default(object, env = baseenv()) : invalid formula
La función genérica plot() cuando encuentra un objeto de la clase ((lm))

selecciona de entre sus métodos plot.lm, pero aquı́ se encuentra con un objeto
al que erróneamente se le ha asignado la clase ((lm)) y no puede trabajar con él,
ya que únicamente es un vector numérico, por lo que se genera un error. Es
misión del programador no cometer estos errores (esto no sucede con la clase
S4).
Para ver los métodos asociados a una función genérica se utiliza la función
methods().
Ejemplo 29.2. ¿Qué métodos existen para la función plot()?
> methods(plot)
[1] plot,ANY-method plot,color-method
[3] plot.aareg* plot.acf*
[5] plot.agnes* plot.areg
[7] plot.areg.boot plot.aregImpute
[9] plot.biVar plot.clusGap*
[11] plot.correspondence* plot.cox.zph*
[13] plot.curveRep plot.data.frame*
[15] plot.decomposed.ts* plot.default
[17] plot.dendrogram* plot.density*
[19] plot.diana* plot.drawPlot
1 Según Chambers: ((It does not allow many of the techniques we need to produce clear and reliable
software. [161]))

29.6. TIPOS DE OOP 363
[21] plot.ecdf plot.factor*

[23] plot.formula* plot.function
www.editorialuc.es
[25] plot.gbayes plot.ggplot*
[27] plot.gtable* plot.hclust*
[29] plot.histogram* plot.HoltWinters*
[31] plot.isoreg* plot.lda*
[33] plot.lm* plot.mca*
[35] plot.medpolish* plot.mlm*
[37] plot.mona* plot.partition*
[39] plot.ppr* plot.prcomp*
[41] plot.princomp* plot.profile*
[43] plot.profile.nls* plot.Quantile2
[45] plot.raster* plot.ridgelm*
[47] plot.rm.boot plot.rpart*
[49] plot.shingle* plot.silhouette*
[51] plot.spec* plot.spline*
[53] plot.stepfun plot.stl*
[55] plot.summary.formula.response plot.summary.formula.reverse
[57] plot.summaryM plot.summaryP
[59] plot.summaryS plot.survfit*
[61] plot.table* plot.times*
[63] plot.transcan plot.trellis*
[65] plot.ts plot.tskernel*
[67] plot.TukeyHSD* plot.varclus
[69] plot.xyVector*
see ’?methods’ for accessing help and source code
Para ver el código empleado en un método concreto se teclea su nombre:
Ejemplo 29.3. ¿Cómo ver el código del método ((plot.areg))?
> plot.areg
function (x, whichx = 1:ncol(x$x), ...)
{
plot(x$y, x$ty, xlab = x$yname, ylab = paste("Transformed",
x$yname))
r2 <- round(x$rsquared, 3)
title(sub = bquote(Rˆ2 == .(r2)), adj = 0)
xdata <- x$x
cn <- colnames(xdata)
for (i in whichx) plot(xdata[, i], x$tx[, i], xlab = cn[i],
ylab = paste("Transformed", cn[i]), ...)
invisible()
}
<environment: namespace:Hmisc>
En ocasiones el método que se quiere explorar tiene un asterisco, en este ca-

so su código no se puede ver tecleando su nombre, hay que emplear la función
getAnywhere():
Ejemplo 29.4. ¿Cómo ver el código del método ((plot.lm))?

Como en la salida de methods(plot) el método en cuestión aparece como
plot.lm*, el teclear simplemente su nombre no sirve para que aparezca su
código:

> plot.lm # incorrecto

Error: objeto ’plot.lm’ no encontrado
Para ver su código se debe emplear la función getAnywhere(), ya que el

objeto está en otro entorno:
> getAnywhere(plot.lm) # correcto
A single object matching ‘plot.lm’ was found
It was found in the following places
registered S3 method for plot from namespace stats
namespace:stats
with value
----------------------- lı́neas omitidas ------------------------
<bytecode: 0x114d76590>
<environment: namespace:stats>
Se han omitido muchas lı́neas de código porque esta función es muy larga.
Ejemplo de una clase S3

Para entender mejor la clase S3 vamos a desarrollar un ejemplo práctico
aplicado a un estudio en el que se pretende valorar el crecimiento longitudinal
de niños nacidos a término y que son controlados secuencialmente hasta los
24 meses de edad, con mediciones de peso, longitud y perı́metro cefálico. En
primer lugar se escribirá la clase y después los métodos.
Ejemplo 29.5. Defina la clase ((nenes)) para este estudio.
> nenes <- function(

+ id, # código de identificación
+ name, # nombre (Ape1-Ape2, NomNom)
+ sex, # sexo (F = female y M = male)
+ dob, # fecha de nacimiento (YYYY-MM-DD)
+ age, # edad en meses
+ wt, # peso (kg)
+ ht, # longitud (cm)
+ cp # perı́metro cefálico (cm)
+ ) {
+ res <- list(id = id, name = name, sex = sex, dob = dob,
+ data = data.frame(age, wt, ht, cp))
+ class(res) <- ’nenes’
+ res
+ }
La función nenes() devuelve un objeto de la clase nenes, pero este cuan-

do se cree una instancia de esa clase ya que, de momento, la clase de nenes
es:
> class(nenes)
[1] "function"
Ejemplo 29.6. Cree una instancia del objeto nenes.

> age <- c(0, 3, 6, 9, 12, 15, 18, 24)

> wt <- c(3.51, 6.25, 7.99, 9.24, 10.15, 10.8, 11.5, 12.7)
www.editorialuc.es
> ht <- c(50.16, 60.43, 66.74, 71.11, 75.01, 78.5, 81.37, 86.68)
> cp <- c(34.89, 41.17, 44.14, 46.02, 47.28, 48.1, 48.71, 49.59)
> N <- nenes(777, ’Pérez-Pérez, JuanAntonio’, ’M’,
+ as.Date(’2015-08-31’), age, wt, ht, cp)
> N
$id
[1] 777
$name
[1] "Pérez-Pérez, JuanAntonio"
$sex
[1] "M"
$dob
[1] "2015-08-31"
$data
age wt ht cp
1 0 3.51 50.16 34.89
2 3 6.25 60.43 41.17
3 6 7.99 66.74 44.14
4 9 9.24 71.11 46.02
5 12 10.15 75.01 47.28
6 15 10.80 78.50 48.10
7 18 11.50 81.37 48.71
8 24 12.70 86.68 49.59
attr(,"class")
[1] "nenes"
> class(N)
[1] "nenes"
Ejemplo 29.7. Cree un método ((print)).
> print.nenes <- function(x, n) {

+ if (x$id == n) {
+ dat <- x$data
+ cat(’\nDatos del niño id =’, x$id, ’\n’)
+ cat(paste(rep(’=’, 50), collapse = ’’))
+ cat(’\nNombre.............:’, x$name)
+ cat(’\nSexo...............:’,
+ ifelse(x$sex == ’M’, ’masculino’, ’femenino’))
+ cat(’\nFecha de nacimiento:’, format(x$dob, ’%d-%m-%Y’))
+ cat(’\nAntropometrı́a’)
+ cat(’\n’)
+ print(dat)
+ cat(’\n’)
+ } else {
+ cat(’\nNo existe ese nene’)
+ }
+ }

Ejemplo 29.8. Imprima el niño ((777)).
> print(N, 777)
Datos del niño id = 777

==================================================
Nombre.............: Pérez-Pérez, JuanAntonio
Sexo...............: masculino
Fecha de nacimiento: 31-08-2015
Antropometrı́a
age wt ht cp
1 0 3.51 50.16 34.89
2 3 6.25 60.43 41.17
3 6 7.99 66.74 44.14
4 9 9.24 71.11 46.02
5 12 10.15 75.01 47.28
6 15 10.80 78.50 48.10
7 18 11.50 81.37 48.71
8 24 12.70 86.68 49.59
Ejemplo 29.9. Imprima el niño ((778)).
> print(N, 778)
No existe ese nene
Ejemplo 29.10. Cree el método ((plot)).
> plot.nenes <- function(x, n, ...) {

+ if (x$id == n) {
+ dat <- x$data
+ opar <- par(mfrow = c(1, 3))
+ plot(dat$age, dat$wt, type = ’o’, pch = 19,
+ xlab = ’Age (months)’, xlim = c(0, 30),
+ ylab = ’Peso (kg)’, ylim = c(2, 15),
+ main = ’Peso y Edad’)
+ plot(dat$age, dat$ht, type = ’o’, pch = 19,
+ ylab = ’Talla (cm)’, ylim = c(40, 100),
+ main = ’Talla y Edad’)
+ plot(dat$age, dat$cp, type = ’o’, pch = 19,
+ ylab = ’Perim. cefálico (cm)’, ylim = c(30, 50),
+ main = ’Perı́m. cefálico y Edad’)
+ mtext(x$name, side = 3, outer = TRUE,
+ line = -1.5, cex = 1.5)
+ par(opar)
+ }
+ }
Ejemplo 29.11. Dibuje el niño ((777)).
> plot(N, 777)

Figura 29.2: Antropometrı́a del niño ((777)).

Pérez−Pérez, JuanAntonio
www.editorialuc.es
Peso y Edad Talla y Edad Perím. cefálico y Edad
100
50
●
●
14
●
●
90
●
●
12
45
●
●
●
80
●
Perim. cefálico (cm)

●
●
10
●
Talla (cm)
Peso (kg)
● ●
●
70
40
8
●
●
60
●
●
6
35
●
50
●
4
●
40
30
2
0 5 10 15 20 25 30 0 5 10 15 20 25 30 0 5 10 15 20 25 30
Age (months) Age (months) Age (months)
Ejemplo 29.12. Dibuje el niño ((778)).
> plot(N, 778)
No existe ese nene
Por supuesto, los métodos ((print.nenes)) y ((plot.nenes)) han queda-

do incorporados a R.
Ejemplo 29.13. Compruebe que el método ((plot.nenes)) ha quedado in-

corporado a R.
> methods(plot)
[1] plot,ANY-method plot,color-method
[3] plot.aareg* plot.acf*
[5] plot.agnes* plot.areg
[7] plot.areg.boot plot.aregImpute
[9] plot.biVar plot.clusGap*
[11] plot.correspondence* plot.cox.zph*
[13] plot.curveRep plot.data.frame*
[15] plot.decomposed.ts* plot.default
[17] plot.dendrogram* plot.density*
[19] plot.diana* plot.drawPlot
[21] plot.ecdf plot.factor*
[23] plot.formula* plot.function
[25] plot.gbayes plot.ggplot*
[27] plot.gtable* plot.hclust*
[29] plot.histogram* plot.HoltWinters*
[31] plot.isoreg* plot.lda*
[33] plot.lm* plot.mca*
[35] plot.medpolish* plot.mlm*
[37] plot.mona* plot.nenes
[39] plot.partition* plot.ppr*
[41] plot.prcomp* plot.princomp*
[43] plot.profile* plot.profile.nls*
[45] plot.Quantile2 plot.raster*
[47] plot.ridgelm* plot.rm.boot

[49] plot.rpart* plot.shingle*

[51] plot.silhouette* plot.spec*
[53] plot.spline* plot.stepfun
[55] plot.stl* plot.summary.formula.response
[57] plot.summary.formula.reverse plot.summaryM
[59] plot.summaryP plot.summaryS
[61] plot.survfit* plot.table*
[63] plot.times* plot.transcan
[65] plot.trellis* plot.ts
[67] plot.tskernel* plot.TukeyHSD*
[69] plot.varclus plot.xyVector*
En la posición 38 del listado está plot.nenes.
29.6.2. Clase S4
La clase S4 (new-style S4) es el estilo más moderno, estructurado y seguro.
Aún está poco extendido, pero es el aconsejado por Chambers para conseguir
una programación eficiente y segura [161] ya que es mucho más robusto y gus-
ta más a los programadores.
Algunos programadores tienen la sensación que S3 no proporciona la se-
guridad normalmente asociada a la OOP [146], por lo que exigen las clases S4,
que son más seguras aunque más difı́ciles de programar, ya que las estructuras
S4 son mucho más ricas que las estructuras S3:
Toda la información se organiza en slots.
Cada slot tiene nombre y una clase especificada previamente.
La clase de los datos en el slot debe emparejar perfectamente con la del

slot.
Diversas funciones son muy útiles en las clases S4 (Tabla 29.1) [246].
Tabla 29.1: Funciones para las clases S4.
Función Acción
@ Toma o reemplaza el contenido de un slot
new() Crea un nuevo objeto de una determinada clase
setClass() Crea una nueva clase S4
setMethod() Crea un nuevo método S4
setGeneric() Crea una nueva función genérica
getClass() Recoge una definición de clase
getMethod() Recoge una definición de método
getSlots() Recoge el nombre y clase de cada slot
validObject() Comprueba la validez de un objeto

www.editorialuc.es
tablas:
Función Acción
class() Clase de una objeto
data.frame() Crea una data frame
getAnywhere() Ver código de funciones no accesibles
getClass() Recoge una definición de clase
getMethod() Recoge una definición de método
getSlots() Recoge el nombre y clase de cada slot
if() Ejecución condicional
list() Crea listas
methods() Métodos de una función
new() Crea un nuevo objeto de una determinada clase
plot() Función genérica
plot.areg() Método de plot()
plot.nenes() Método de plot()
print() Función genérica
runif Generación aleatoria de números ((uniformes))
setClass() Crea una nueva clase S4
setMethod() Crea un nuevo método S4
setGeneric() Crea una nueva función genérica
summary() Función genérica
validObject() Comprueba la validez de un objeto
Función Acción
microbenchmark Paquete para medir tiempos de ejecución [249]
PROBLEMAS
Problema 1. Amplı́e el método plot.nenes() para que incluya tres gráficos más:
relación peso/talla, ı́ndice de masa corporal y velocidad de crecimiento.
Problema 2. ¿Cuántos métodos tienen la función summary()?

Problema 3. ¿Cuál es el código de la función summary.table()?

Problema 4. ¿Cuántas lı́neas de código tiene la función lm()?
Problema 5. Cree un método que calcule el incremento de peso de cada nene en los
dos primeros años de vida.

www.editorialuc.es
Capı́tulo 30
La función apply y similares
30.1. Introducción
R dispone de una serie de funciones cuyo objetivo es sustituir los lentos

bucles de la programación.
Dependiendo del tipo de objetos sobre los que trabajan y cómo es su salida
se han diseñado distintas funciones, como se precia en la Tabla 30.1.
Tabla 30.1: Caracterı́sticas de ((apply() & friends)).
Función Entrada Acción Salida

apply() array Aplica una función sobre los array o lista
márgenes de un objeto.
lapply() lista Aplica una función sobre los ele- lista
vector mentos de una lista o vector.
sapply() lista Aplica una función sobre los ele- lista simpli-
vector mentos de una lista o vector. ficada
tapply() vector Aplica una función sobre los depende de
+ factor elementos de un vector según los factores
un/os factor/es. (array)
by() dataframe Aplica una función sobre un da- lista
+ factor taframe según un/os factor/es.
aggregate() dataframe Aplica una función sobre las co- dataframe
+ factor lumnas de un dataframe según
un factor/es.
mapply() array Aplica una función a múltiples array o lista
estructuras de datos.
371
372 CAPÍTULO 30. LA FUNCIÓN APPLY Y SIMILARES
30.2. Sobre arrays

30.2.1. apply()
La función apply() aplica una función a los márgenes (((1)) [filas] o ((2)) [co-
lumnas]) de un objeto que tiene dimensiones (array, matriz, data frame) pero
que no es una lista ni un vector..
#---------------------------------------------------------------
apply(X, MARGIN, FUN, ...)
#---------------------------------------------------------------
¿Qué funciones se pueden usar? Tanto las funciones de R como las defini-
das por el usuario.
Si el objeto es una matriz tiene dos dimensiones:
Ejemplo 30.1. Con la siguiente matriz 6x7 calcule la media por filas y por
columnas.
> set.seed(2016)
> (M <- matrix(rpois(42, 5), nr=6))
[,1] [,2] [,3] [,4] [,5] [,6] [,7]
[1,] 3 6 3 5 8 6 3
[2,] 3 8 8 2 5 7 4
[3,] 7 0 3 4 3 3 3
[4,] 3 2 4 6 5 8 6
[5,] 5 4 6 4 9 7 4
[6,] 2 4 3 5 4 3 2
> (media_f <- apply(M, 1, mean)) # media por filas
[1] 4.857143 5.285714 3.285714 4.857143 5.571429 3.285714
> (media_c <- apply(M, 2, mean)) # media por columnas
[1] 3.833333 4.000000 4.500000 4.333333 5.666667 5.666667
[7] 3.666667
Si el objeto es un array tiene dos o más de dos dimensiones:
Ejemplo 30.2. Con el siguiente array 4x5x3 calcule el total por filas, por co-
lumnas y por matrices.
> set.seed(2016)
> (A <- array(rpois(60, 8), dim = c(4, 5, 3)))
, , 1
[,1] [,2] [,3] [,4] [,5]

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

[1,] 7 12 13 5 6
[2,] 9 9 7 11 6

30.2. SOBRE ARRAYS 373
[3,] 7 5 9 11 6
[4,] 8 9 11 5 9
www.editorialuc.es
, , 3
[,1] [,2] [,3] [,4] [,5]

[1,] 7 7 8 6 11
[2,] 4 6 8 7 4
[3,] 6 10 5 12 5
[4,] 9 6 7 8 7
> (apply(A, 1, sum))

[1] 111 101 117 113
[1] 83 98 86 95 80
[1] 134 165 143
Si el objeto es un dataframe (es una lista con todos sus elementos de igual
longitud):
Ejemplo 30.3. Calcule la media de las variables 2:8 (emb, glu p, tad, ptri,
imc, fp dia, edad) de la BdD pima.
> load(’bd_Pima.RData’)
> round(apply(.data[, 2:8], 2, mean, na.rm = TRUE), 2)
emb glu_p tad ptri imc fp_dia edad
3.63 121.39 71.96 29.16 32.68 0.48 32.16
En este ejemplo se aplica apply() sobre un dataframe y devuelve un obje-

to más sencillo, concretamente un vector.
Ejemplo 30.4. ¿Cuántos NA hay en la BdD pima?
> M <- apply(.data, 2, is.na) # matrix con TRUE o FALSE

> x <- apply(M, 2, sum) # vector
> (df <- data.frame(x)) # dataframe
x
id 0
emb 0
glu_p 0
tad 13
ptri 98
imc 3
fp_dia 0
edad 0
diab 0
emb_c 0
en 3

30.3. Sobre listas

30.3.1. lapply()
La función lapply() aplica una función a cada uno de los elementos de
una lista y devuelve una lista.
#---------------------------------------------------------------
lapply(X, FUN, ...)
#---------------------------------------------------------------
Ejemplo 30.5. Suponga que formamos una lista con estos tres vectores:
runif(7, 3, 12), rnorm(6) y rpois(10, 3). Calcule la media em-
pleando lapply().
> set.seed(2)
> x1 <- runif(7, 3, 12)
> x2 <- rnorm(6)
> x3 <- rpois(10, 3)
> (lista <- list(uniforme = x1, normal = x2, poisson = x3))
$uniforme
[1] 4.663940 9.321366 8.159937 4.512467 11.494554 11.491275
[7] 4.162431
$normal
[1] 0.9678839 0.1256203 -0.7098623 -0.9122442 1.0517744
[6] -0.7526655
$poisson
[1] 1 4 2 5 1 2 3 1 2 6
Como se puede apreciar, lista es un objeto lista con tres componentes, el

primero de longitud 7, el segundo de longitud 6 y el tercero de longitud 10,
todos ellos de tipo numérico, por tanto es posible calcular su media:
> unlist(lapply(lista, mean))

uniforme normal poisson
7.68656720 -0.03824892 2.70000000
Ahora vamos a realizar un cálculo algo más complicado: en una BdD (que
ya sabemos que es una lista) vamos a realizar varios cálculos:
Ejemplo 30.6. Calcule el número de personas, la media y la DE del IMC

de las indias pima según su estado nutricional empleando la BdD pima que
está en el fichero ((bd Pima.RData))..
> library(epicalc)
> use(.data)
> casos <- unlist(lapply(split(imc, en), length))
> media <- unlist(lapply(split(imc, en), mean))
> DE <- unlist(lapply(split(imc, en), sd))
> round(rbind(casos, media, DE), 2)

30.3. SOBRE LISTAS 375
NO SO OB
casos 79.00 152.00 398.00
www.editorialuc.es
media 22.54 27.50 36.67
DE 1.85 1.47 5.30
Con la función split() se ha convertido el vector numérico imc en una

lista con tres componentes: los IMC del estado nutricional (en) normal, sobre-
peso y obesidad. La función lapply() aplica una función (longitud, media,
DE) a esa lista. Finalmente, con rbind() se crea una matriz para presentar los
resultados.
Ejemplo 30.7. Calcule los coeficientes de regresión (intersect, slope) siendo

el número de embarazos (emb) la variable independiente y el IMC (imc) la
variable dependiente para cada una de las tres categorı́as del estado nutri-
cional (en).
> lapply(split(.data, en),

+ function(.data) lm(imc ˜ emb, data = .data)$coef)
$NO
(Intercept) emb
22.28495720 0.09101956
$SO
(Intercept) emb
27.33192647 0.04710158
$OB
(Intercept) emb
37.3197441 -0.1725603
La función lapply() calcula una lista con los coeficientes pedidos.
30.3.2. sapply()
La función sapply() aplica una función a cada uno de los elementos de
una lista y devuelve un objeto simplificado.
#---------------------------------------------------------------
sapply(X, FUN, ..., simplify = TRUE, USE.NAMES = TRUE)
#---------------------------------------------------------------
R intenta que el objeto devuelto por sapply() sea lo más simplificado

posible (vector, matriz o lista).
Ejemplo 30.8. Cree un objeto de la clase lista con x = 1:10,

y = exp(-3:3), z = c(TRUE, FALSE, FALSE, TRUE) y g =
letters[1:4]. Calcule la longitud de sus componentes, quantiles de
los tres primeros y el número de caracteres de los cuatro.
> obj <- list(x = 1:10,

+ y = exp(-3:3),
+ z = c(TRUE, FALSE, FALSE, TRUE),
+ g = letters[1:4])

> obj
$x
[1] 1 2 3 4 5 6 7 8 9 10
$y
[1] 0.04978707 0.13533528 0.36787944 1.00000000 2.71828183
[6] 7.38905610 20.08553692
$z
[1] TRUE FALSE FALSE TRUE
$g
[1] "a" "b" "c" "d"
> sapply(obj, length) # devuelve un vector

x y z g
10 7 4 4
> sapply(obj[1:3], quantile) # devuelve una matriz
x y z
0% 1.00 0.04978707 0.0
25% 3.25 0.25160736 0.0
50% 5.50 1.00000000 0.5
75% 7.75 5.05366896 1.0
100% 10.00 20.08553692 1.0
> sapply(obj, nchar) # devuelve una lista
$x
[1] 1 1 1 1 1 1 1 1 1 2
$y
[1] 18 17 17 1 16 16 16
$z
[1] 4 5 5 4
$g
[1] 1 1 1 1
Ejemplo 30.9. Otros ejemplos de cómo sapply() intenta simplificar.
> sapply(1:4,function(x) rnorm(3,x))

[,1] [,2] [,3] [,4]
[1,] 2.9951861 1.733865 3.590485 3.643311
[2,] 0.4388476 2.206614 1.813993 3.415924
[3,] 1.6703920 3.347627 3.739341 4.163280
> sapply(1:4,function(x) rpois(5,x))
[,1] [,2] [,3] [,4]
[1,] 1 2 1 6
[2,] 4 3 3 6
[3,] 0 3 6 3
[4,] 1 0 3 9
[5,] 2 2 3 6
> sapply(1:4,function(x) matrix(x,2,2))
[,1] [,2] [,3] [,4]
[1,] 1 2 3 4

30.4. SOBRE VECTORES 377
[2,] 1 2 3 4
[3,] 1 2 3 4
www.editorialuc.es
[4,] 1 2 3 4
> sapply(1:4,function(x) matrix(x,2,2), simplify = "array")
, , 1
[,1] [,2]
[1,] 1 1
[2,] 1 1
, , 2
[,1] [,2]
[1,] 2 2
[2,] 2 2
, , 3
[,1] [,2]
[1,] 3 3
[2,] 3 3
, , 4
[,1] [,2]
[1,] 4 4
[2,] 4 4
Ejemplo 30.10. Calcule los coeficientes de regresión (intersect, slope) siendo

el número de embarazos (emb) la variable independiente y el IMC (imc) la
variable dependiente para cada una de las tres categorı́as del estado nutri-
cional (en). Repita los cálculos, pero que la salida sea más simple.
> sapply(split(.data, en),

+ function(.data) lm(imc ˜ emb, data = .data)$coef)
NO SO OB
(Intercept) 22.28495720 27.33192647 37.3197441
emb 0.09101956 0.04710158 -0.1725603
Con la función sapply() se obtiene una matriz.
30.4. Sobre vectores

30.4.1. tapply()
La función tapply() aplica una función a los elementos de un vector
según un factor.
#---------------------------------------------------------------
tapply(X, INDEX, FUN = NULL, ..., simplify = TRUE)
#---------------------------------------------------------------

Ejemplo 30.11. Con la BdD de las indias pima, calcule el IMC medio según
sean o no diabéticas.
> library(epicalc); use(.data)
> tapply(imc, diab, mean, na.rm = TRUE)
N S
31.19157 35.56449
La función tapply() también puede ((trocear)) el vector según la combina-

ción de dos o más factores, que se pasan como una lista
Ejemplo 30.12. Con la BdD de las indias pima, calcule el IMC medio según
sean o no diabéticas y que tengan una TAD > 90 mm Hg.
> tapply(imc, list(diab, tad > 90), mean, na.rm = TRUE)

FALSE TRUE
N 31.12955 35.42143
S 35.16891 41.63077
A caballo entre vectores y dataframes está:
30.4.2. split()
La función split() divide un vector o un dataframe según un factor o
una lista de factores.
Ejemplo 30.13. Divida el IMC según sean o no diabéticas las indias Pima.
> split(.data$imc, .data$diab)

$N
[1] 30.2 35.8 47.9 26.4 34.3 25.9 32.4 30.9 41.3 23.2 25.4 22.1
-------------------- lı́neas omitidas --------------------
[409] 28.5 40.6 30.0 39.0 26.0 28.4 32.9 26.2 30.4
$S
[1] 25.1 35.6 43.3 43.1 30.1 27.6 36.6 29.3 30.8 42.6 34.3 33.7
-------------------- lı́neas omitidas --------------------
[205] 38.0 41.2 33.9 33.8 44.5 42.3 49.3 36.4 43.3 36.5 44.0
Ejemplo 30.14. Divida el IMC según que las indias Pima presenten una TAD
superior a 90 mm Hg o no.
> x <- split(.data$imc, .data$tad > 90)

> lapply(x, length)
$‘FALSE‘
[1] 591
$‘TRUE‘
[1] 28
Ejemplo 30.15. Divida el IMC según sean o no diabéticas las indias Pima y
presenten o no una TAD > 90 mm Hg.

30.5. SOBRE DATA FRAMES 379
> x <- split(.data$imc, list(.data$diab, .data$tad > 90))

> lapply(x, length)
www.editorialuc.es
$N.FALSE
[1] 398
$S.FALSE
[1] 193
$N.TRUE
[1] 14
$S.TRUE
[1] 14
30.5. Sobre data frames

30.5.1. by()
La función by() divide un data frame en subconjuntos según un factor o
lista de factores y luego aplica a cada subconjunto (sub data frame) una fun-
ción. Emula el comportamiento de tapply(), pero aplicado a data frames.
#---------------------------------------------------------------
by(data, INDICES, FUN, ..., simplify = TRUE)
#---------------------------------------------------------------
Ejemplo 30.16. Presente un resumen de la BdD de las indias Pima no diabéti-

cas y otro resumen de las diabéticas.
> by(data = .data[, 2:8],

+ INDICES = diab,
+ FUN = summary)
diab: N
emb glu_p tad
Min. : 0.000 Min. : 56.0 Min. : 24.00
1st Qu.: 1.000 1st Qu.: 94.0 1st Qu.: 62.00
Median : 2.000 Median :107.0 Median : 70.00
Mean : 3.074 Mean :110.4 Mean : 70.44
3rd Qu.: 5.000 3rd Qu.:125.0 3rd Qu.: 78.00
Max. :13.000 Max. :197.0 Max. :110.00
NA’s :5
ptri imc fp_dia edad
Min. : 7.00 Min. :18.20 Min. :0.0780 Min. :21.0
1st Qu.:19.00 1st Qu.:26.00 1st Qu.:0.2350 1st Qu.:23.0
Median :27.00 Median :30.70 Median :0.3420 Median :26.0
Mean :27.27 Mean :31.19 Mean :0.4334 Mean :30.1
3rd Qu.:33.00 3rd Qu.:35.70 3rd Qu.:0.5710 3rd Qu.:34.0
Max. :60.00 Max. :57.30 Max. :2.3290 Max. :81.0
NA’s :60 NA’s :2
------------------------------------------------
diab: S
emb glu_p tad ptri

Min. : 0.000 Min. : 78.0 Min. : 30 Min. : 7.00

1st Qu.: 1.000 1st Qu.:118.5 1st Qu.: 68 1st Qu.:27.00
Median : 4.000 Median :142.0 Median : 74 Median :32.00
Mean : 4.702 Mean :142.6 Mean : 75 Mean :32.98
3rd Qu.: 8.000 3rd Qu.:168.0 3rd Qu.: 83 3rd Qu.:39.00
Max. :17.000 Max. :199.0 Max. :114 Max. :99.00
NA’s :8 NA’s :38
imc fp_dia edad
Min. :22.90 Min. :0.1270 Min. :21.00
1st Qu.:31.12 1st Qu.:0.2840 1st Qu.:27.50
Median :34.30 Median :0.5030 Median :34.00
Mean :35.56 Mean :0.5833 Mean :36.16
3rd Qu.:38.50 3rd Qu.:0.7510 3rd Qu.:43.00
Max. :67.10 Max. :2.4200 Max. :70.00
NA’s :1
30.5.2. aggregate()
La función aggregate() divide un data frame en subconjuntos y calcula
en cada uno de ellos un estadı́stico1
#---------------------------------------------------------------
aggregate(x, by, FUN, ..., simplify = TRUE, drop = TRUE)
aggregate(formula, data, FUN, ...,

subset, na.action = na.omit)
#---------------------------------------------------------------
Ejemplo 30.17. Calcule la media de las variables 2:8 de la BdD de las indias
Pima empleando la función aggregate().
> aggregate(.data[, 2:8], list(diab), mean, na.rm = TRUE)

Group.1 emb glu_p tad ptri imc fp_dia
1 N 3.074341 110.4365 70.43689 27.26611 31.19157 0.4333813
2 S 4.702326 142.6279 75.00000 32.97740 35.56449 0.5832651
edad
1 30.09832
2 36.16279
Ejemplo 30.18. Calcule la edad media en diabéticas y no diabéticas utilizan-

do la función aggregate().
> aggregate(edad ˜ diab, data = .data, mean)

diab edad
1 N 30.09832
2 S 36.16279
Ejemplo 30.19. Calcule la media de las variables 2:8 de la BdD de las indias
Pima empleando la función aggregate() utilizando una fórmula.
1 De la ayuda de R: ((Splits the data into subsets, computes summary statistics for each, and returns the
result in a convenient form [116])).

30.6. OTRAS 381
> aggregate(. ˜ diab, data = .data, mean)

diab id emb glu_p tad ptri imc
www.editorialuc.es
1 N 331.8282 2.926761 110.0169 69.91268 27.29014 31.42958
2 S 323.0452 4.700565 143.1186 74.70056 32.97740 35.81977
fp_dia edad emb_c en
1 0.4463155 29.22254 2.290141 2.391549
2 0.6165876 36.41243 2.711864 2.824859
30.6. Otras
30.6.1. mapply()
La función mapply() es una versión multivariable de sapply()
#---------------------------------------------------------------
mapply(FUN, ..., MoreArgs = NULL, SIMPLIFY = TRUE,
USE.NAMES = TRUE)
#---------------------------------------------------------------
Ejemplo 30.20. Cree una matriz con una fila 4:8 repetida 6 veces.
> mapply(rep, 4:8, 6)

[,1] [,2] [,3] [,4] [,5]
[1,] 4 5 6 7 8
[2,] 4 5 6 7 8
[3,] 4 5 6 7 8
[4,] 4 5 6 7 8
[5,] 4 5 6 7 8
[6,] 4 5 6 7 8
30.6.2. vapply()
Es una función similar a sapply(), solamente que se pre-especifica el tipo
de valor que devuelve, por lo que es un poco más segura (y posiblemente más
rápida).
#---------------------------------------------------------------
vapply(X, FUN, FUN.VALUE, ..., USE.NAMES = TRUE)
#---------------------------------------------------------------
Ejemplo 30.21. Dada la lista formada por los vectores: x1 = rpois(1e7, 25),
x2 = exp(-300:300) + log(1.6) y x3 = 1:1e7. Calcule la desviación estándar de
cada vector.
> set.seed(2016)
> x <- list(x1 = rpois(1e7, 25), # length = 1e7
+ x2 = exp(-300:300) + log(1.6), # length = 601
+ x3 = 1:1e7) # length = 1e7
> vapply(X = x, FUN = sd, FUN.VALUE = 0)
x1 x2 x3
4.997640e+00 8.512592e+128 2.886751e+06

Se le dice a vapply() que debe devolver un único número por cada uno
de los vectores; ası́ lo hace, devolviendo un vector con las tres desviaciones
estándar.
Ejemplo 30.22. ¿Es más rápida la función vapply() que lapply() o

sapply()?
Aunque la documentación de R dice que puede ser más rápida, con la lista del
ejemplo anterior obtenemos el siguiente resultado:
> system.time(vapply(x, FUN = sd, FUN.VALUE = 0))
user system elapsed
0.091 0.001 0.093
> system.time(sapply(x, FUN = sd))
user system elapsed
0.092 0.001 0.094
> system.time(lapply(x, FUN = sd))
user system elapsed
0.092 0.001 0.094
Luego no parece haber diferencias...
30.6.3. eapply()
La función eapply() es similar a lapply() pero en vez de aplicar una
función a cada elemento de una lista, la aplica a cada elemento en un entorno
y devuelve una lista.
#---------------------------------------------------------------
eapply(env, FUN, ..., all.names = FALSE, USE.NAMES = TRUE)
#---------------------------------------------------------------
Ejemplo 30.23. Encuentre todas las funciones definidas por el usuario en el

entorno global.
> x1 <- 1:10

> x2 <- seq(0, 24, 6)
> x3 <- list(x = 1, y = 2:7)
> f <- function(x) {x + 1}
> eapply(.GlobalEnv, is.function)
$f
[1] TRUE
$x1
[1] FALSE
$x2
[1] FALSE
$x3
[1] FALSE
Supongamos que no hay nada y se crean las tres variables y una función.
Cuando se ejecuta eapply() nos presenta los cuatro objetos que hay en el
entorno y nos dice cuál de ellos es una función.

30.6. OTRAS 383
30.6.4. outer()
Calcula el producto externo.
www.editorialuc.es
#---------------------------------------------------------------
outer(X, Y, FUN = "*", ...)
X %o% Y
#---------------------------------------------------------------
Ejemplo 30.24. Calcule la tabla del 9 empleando la función outer().

> 1:9 %o% 1:9
[,1] [,2] [,3] [,4] [,5] [,6] [,7] [,8] [,9]
[1,] 1 2 3 4 5 6 7 8 9
[2,] 2 4 6 8 10 12 14 16 18
[3,] 3 6 9 12 15 18 21 24 27
[4,] 4 8 12 16 20 24 28 32 36
[5,] 5 10 15 20 25 30 35 40 45
[6,] 6 12 18 24 30 36 42 48 54
[7,] 7 14 21 28 35 42 49 56 63
[8,] 8 16 24 32 40 48 56 64 72
[9,] 9 18 27 36 45 54 63 72 81
Ejemplo 30.25. Con los vectores a = 1:3 y b = 10:7. Calcule el producto ex-
terno y aplique outer() con pmax y pmin.
> a <- 1:3
> b <- 10:7
> a %o% b
[,1] [,2] [,3] [,4]
[1,] 10 9 8 7
[2,] 20 18 16 14
[3,] 30 27 24 21
> outer(a, b, ’*’)
[,1] [,2] [,3] [,4]
[1,] 10 9 8 7
[2,] 20 18 16 14
[3,] 30 27 24 21
> outer(a, b, pmax)
[,1] [,2] [,3] [,4]
[1,] 10 9 8 7
[2,] 10 9 8 7
[3,] 10 9 8 7
> outer(a, b, pmin)
[,1] [,2] [,3] [,4]
[1,] 1 1 1 1
[2,] 2 2 2 2
[3,] 3 3 3 3
30.6.5. sweep()
#---------------------------------------------------------------
sweep(x, MARGIN, STATS, FUN = "-", check.margin = TRUE, ...)
#---------------------------------------------------------------

Ejemplo 30.26. Suponga que desea centrar los vectores numéricos (2:8) de la
BdD Pima restando a cada vector su media.
> round(sweep(data.matrix(.data[2:8]), 2, media_pima), 1)

emb glu_p tad ptri imc fp_dia edad
1 1.4 -35.4 -4 -1.2 -2.5 -0.1 -8.2
2 3.4 73.6 -2 3.8 -7.6 -0.3 22.8
----------- lı́neas omitidas ----------
631 1.4 -0.4 0 -6.2 -6.5 -0.2 -2.2
632 -2.6 -28.4 -2 1.8 -2.3 -0.2 -9.2
Ejemplo 30.27. Suponga que a la matriz M = c(1:25, nr = 5) le quiere multi-

plicar a la primera fila por 1, a la segunda por 2, ... a la quinta por 5. Emplee
sweet()
> M <- matrix(1:15, nr = 5)

> M
[,1] [,2] [,3]
[1,] 1 6 11
[2,] 2 7 12
[3,] 3 8 13
[4,] 4 9 14
[5,] 5 10 15
> sweep(M, 1, 1:5, ’*’)
[,1] [,2] [,3]
[1,] 1 6 11
[2,] 4 14 24
[3,] 9 24 39
[4,] 16 36 56
[5,] 25 50 75
30.7. Funciones en este tema

En este tema se han utilizado las funciones recogidas en la siguiente Tabla:
Función Acción
aggregate() Divide un dataframe y aplica una función
apply() Aplica una función a los márgenes de un array
array() Crea una array
by() Divide un data frame según un factor y aplica una función
eapply() Aplica una función a cada elemento de un entorno
exp() Número e elevado a una potencia
data.frame() Crea un data frame
lapply() Aplica una función a cada elemento de una lista
library() Carga una librerı́a

30.7. FUNCIONES EN ESTE TEMA 385
Función Acción
www.editorialuc.es
mapply() Versión multivariable de sapply()
mean() Media de un vector numérico
nchar() Calcula el número de caracteres
outer() Producto externo
quantile() Calcula cuantiles
rnorm() Vector de elementos que siguen una distribución normal
round() Función de redondeo
rpois() Genera números aleatorios de Poisson
runif() Genera números aleatorios de distribución uniforme
sapply() Aplica una función sobre los elementos de una lista y simplifica
sd() Calcula la desviación estándar de un vector numérico
split() Divide un vector o dataframe según un factor
sweep() Aplica una función por filas/columnas a un dataframe
system.time() Calcula el tiempo empleado por una función
tapply() Trocea un vector según un factor y aplica una función
unlist() Elimina la caracterı́stica de lista
use() Crea una copia oculta (.data) de una data frame
vapply() Aplica una función sobre una lista de forma segura
PROBLEMAS
Problema 1. Escriba una función que calcule los marginales (total de cada una de las
filas y de cada una de las columnas) utilizando algún bucle (for o while). Compare
su tiempo de ejecución con otro método vectorizado.
Problema 2. Con rpois(longitud, media = 6) cree una lista con 7 vec-
tores numéricos de longitud (1:7)*3. Presente la lista. Ordene todos los vectores y
presente la lista ordenada. set.seed(2) para reproducibilidad.
Problema 3. Cree una matriz aleatoria de 7x6 con la función rpois(42, 12).
Encuentre el valor mı́nimo de cada columna.
Problema 4. Calcule la media y la desviación estándar de todas las variables numéri-
cas de la BdD de las indias Pima y presente dichos valores en una matriz.
Problema 5. Escriba una función, empleando alguna de las funciones vistas en este
capı́tulo, que calcule el número de variables numéricas existente en una BdD.

Problema 6. Compruebe el funcionamiento de la función anterior con la BdB de la

Fuerza en adolescentes.
Problema 7. ¿El producto externo de un vector numérico y uno de caracteres puede

ser una matriz? Compruébelo.

www.editorialuc.es
Capı́tulo 31
Programación eficiente
R es un lenguaje interpretado, es decir que su código se ejecuta bajo el

intérprete de R, de manera que no puede ser tan rápido como un lenguaje com-
pilado en un ejecutable. Por tanto, hay que hacer todos los esfuerzos posibles
para conseguir aumentar la velocidad.
De acuerdo con Wickham [148], conviene distinguir dos aspectos, por un
lado el propio lenguaje en sı́ y por otro lado su implementación. Intentando
mejorar sobre estos dos aspectos se podrá conseguir aumentar la velocidad de
ejecución de los programas.
31.1. Medición de la velocidad

Hay varias herramientas para medir la velocidad de ejecución.
31.1.1. La función system.time()

La función system.time() permite evaluar el tiempo consumido en la
ejecución de un determinado procedimiento.
#---------------------------------------------------------------
system.time(expr, gcFirst = TRUE)
#---------------------------------------------------------------
Ejemplo 31.1. Compruebe el tiempo que lleva ejecutar 10000 veces el cálculo
de la media de 1000 números aleatorios que siguen una distribución normal
y finalmente hacer un histograma de las medias calculadas.
En primer lugar se programa la función f1():
> f1 <- function(
+ n1, # número de vueltas
+ n2 # números aleatorios
+ ) {
+ m <- numeric() # vector numérico vacı́o
+ for (i in 1:n1) { # vueltas
+ m <- c(m, mean(rnorm(n2))) # vector de medias
+ }
387
388 CAPÍTULO 31. PROGRAMACIÓN EFICIENTE
+ hist(m, col = ’cyan’, main = ’’) # histograma

+ m # devuelve el vector m
+ }
A continuación se evalúa el tiempo:
> set.seed(2016)
> system.time(f1(1e4, 1e3))
user system elapsed
3.385 0.082 3.458
Figura 31.1: Histograma de las 10000 medias.

1500
Frequency
500
0
−0.15 −0.10 −0.05 0.00 0.05 0.10
El problema de la función system.time() es que no es muy precisa, como

se demuestra con el siguiente ejemplo:
Ejemplo 31.2. Repita el ejemplo anterior.
> system.time(f1(1e4, 1e3))

user system elapsed
3.443 0.076 3.521
Se aprecia que el tiempo es diferente. Por lo tanto, para tener un tiempo más
preciso habrı́a que repetir muchas veces el experimento y calcular una media...
31.1.2. La función microbenchmark()

La función microbenchmark() del paquete microbenchmark es la me-
jor herramienta para esta tarea en R, [148] ya que proporciona tiempos más
precisos, incluso cuando los tiempos son muy bajos.

31.2. ACTUACIÓN SOBRE EL LENGUAJE 389
#---------------------------------------------------------------
microbenchmark(..., list = NULL, times = 100L, unit,
check = NULL, control = list())
www.editorialuc.es
#---------------------------------------------------------------
Ejemplo 31.3. Repita el ejemplo anterior utilizando la función más precisa

microbenchmark().
> microbenchmark(f1(1e4, 1e3), times = 1)

Unit: seconds
expr min lq mean median uq max neval
f1(10000, 1000) 3.431944 3.431944 3.431944 3.431944 3.431944 3.431944 1
La ejecución ha llevado 3.43 segundos.

Esta función microbenchmark() permite hacer comparaciones, calculan-
do el promedio de un número de veces (por defecto 100, esto se hace con el
parámetro times).
Ejemplo 31.4. Compare dos maneras de calcular la media con

microbenchmark().
> x <- rnorm(10000)
> microbenchmark(
+ sum(x) / length(x),
+ mean(x)
+ )
Unit: microseconds
expr min lq mean median uq
sum(x)/length(x) 138.759 140.745 145.8416 142.636 144.3325
mean(x) 198.136 201.761 218.3390 206.175 224.6735
max neval cld
197.405 100 a
432.183 100 b
Es más eficiente que mean() la otra forma...
31.2. Actuación sobre el lenguaje

Este es un aspecto en el que poco se va a insistir en este libro de nivel in-
troductorio, pero sı́ hemos de decir que R es un lenguaje de programación ex-
tremadamente dinámico [148] lo que permite modificaciones de cualquier cosa
después de creada, por ejemplo los argumentos de una función, o los métodos
de una función, etc., lo que permite hacer cambios que agilicen la ejecución.
31.3. Actuación sobre la implementación

Este aspecto es más importante para el principiante, ya que aquı́ puede
seguir alguno de los consejos proporcionados por autores de prestigio [247,
248]:
Use funciones vectorizadas [146]
Inicialize los objetos en toda su longitud antes de un bucle [96] y evite ir
incrementando el tamaño de un objeto en cada paso de un bucle [151].

390 CAPÍTULO 31. PROGRAMACIÓN EFICIENTE
Saque las computaciones fuera de un bucle [96].

Si es posible y razonable, evite los bucles [115].
No evite los bucles simplemente por evitar bucles [96].
Antes de finalizar compruebe la velocidad de su programa, el uso de la
memoria y la elegancia del código [115].
Aprenda a usar las herramientas de depuración [96].
Documente su programa [96].

tablas:
Función Acción
cbind() Junta objetos por columnas
debug() Inicia el depurador
is.numeric() Comprueba si un objeto es numérico
rownames() Asigna nombres por columnas
traceback() Ejecuta hasta el error
Función Acción
microbenchmark Paquete para medir tiempos de ejecución [249]

www.editorialuc.es
Bibliografı́a
[1] Indrayan A. Elements of medical research. Indian J Med Res. 2004;119:93–100.

[2] Bekkering GE, Kleijnen J. Procedures and methods of benefit assessments for medicines in
Germany. Eur J Health Econ. 2008;9 (Suppl 1):S5–S29.
[3] Haas EB. When Knowledge is Power: Three Models of Change in International Organiza-
tions. Berkeley, Califormia (USA): University of Califormia Press; 1990.
[4] Real Academia Española. Diccionario de la Lengua Española. 21st ed. Madrid (España):
Espasa-Calpe; 1992.
[5] Rebagliato M, Ruiz I, Arrazn M. Metodologı́a de investigación en Epidemiologı́a. Madrid
(España): Dı́az de Santos; 1996.
[6] Argimón Pallás JM, Jiménez Villa J. Métodos de investigación clı́nica y epidemiológica. 3rd
ed. Madrid: Elsevier; 2004.
[7] Garcı́a Roldán JL. Cómo elaborar un proyecto de investigación. Alicante (España): Secreta-
riado de Publicaciones. Universidad de Alicante; 1995.
[8] Box GEP, Hunter WG, Hunter JS. Statistics for Experimenters. An introduction to design,
data analysis, and model building. New York (USA): John Wiley & Sons; 1978.
[9] Betz F. Managing Science. Methodology and Organization of Research. Springer; 2011.
[10] Hume D. A Treatise of Human Nature. London (UK): C. Bordet; 1740.
[11] Hume D. A Treatise of Human Nature. Oxford (UK): Clarendon Press; 1967.
[12] Hume D. An Enquiry concerning the human Understanding (1777). 3rd ed. Oxford (UK):
Clarendon Press; 1975.
[13] Chalmers AF. What is this thing called Science?: An Assessment of the Nature and Status of
Science and Its Methods. 3rd ed. St. Lucia, Queensland (Australia): University Queensland
Press; 1999. ISBN 978-0-7022-3093-6 (Traducción de JA Padilla Qué es esa cosa llamada
Ciencia? Madrid: Siglo XXI, Reimpresión 2012).
[14] Popper KR. Logik der Forschung. Zur Erkenntnistheorie der modernen Naturwissenschaft.
Vienna (Austria): Mohr Siebeck; 1934. Fue traducido al inglés por él mismo: The Logic of
Scientific Discovery en 1959.
[15] Popper KR. The Open Society and its Enemies. London (UK): Routledge; 1945.
[16] Popper KR. Postscript to the Logic Scientific Discovery, I: realism and the aim of Science.
London (UK): Hutchinson; 1956.
[17] Popper KR. Conjectures and Refutations: The Growth of Scientific Knowledge. London
(UK): Routledge & Kegan Paul; 1963.
[18] Popper KR. Objective Knowledge: An Evolutionary Approach. Oxford (UK): Clarendon
Press; 1972.
[19] Popper KR. Autobiography of Karl Popper. In: Schilpp PA, editor. The Philosophy of Karl
Popper. La Salle, Illinois (USA): Open Court; 1974. p. 1059–1065.
[20] Valor Yébenes JA. Metodologı́a de la Investigación Cientı́fica. Madrid (España): Biblioteca
Nueva; 2000.
[21] Asensi-Artiga V, Parra-Pujante A. El método cientı́fico y la nueva filosofı́a de la ciencia.
Anales de Documentación. 2002;5:9–19.
391
392 BIBLIOGRAFÍA
[22] Kuhn TS. The Copernican Revolution: Planetary Astronomy in the Development of Western
Thought. Cambridge, Massachusetts (USA): Harvard University Press; 1957. ISBN 0-674-
17103-9.
[23] Kuhn TS. The Structure of Scientific Revolutions. 1st ed. Chicago (USA): University of
Chicago Press; 1962. Traducción española por Carlos Solı́s Santos: La estructura de las revo-
luciones cientı́ficas, 3 ed. México, 2006.
[24] Kuhn TS. The Structure of Scientific Revolutions. 2nd ed. Chicago (USA): University of
Chicago Press; 1970.
[25] Kuhn TS. Objectivity, Value Judgment, and Theory Choice. 1973;p. 356–367.
[26] Kuhn TS. Second Thoughts on Paradigms. In: Suppe F, editor. The Structure of Scientific
Theories. Urbana, Illinois (USA): University of Illinois Press; 1974. p. 459–482.
[27] Kuhn TS. Theory-Change as Structure-Change: Comments on the Sneed Formalism. Er-
kenntnis. 1976;10:179–199.
[28] Kuhn TS. The Essential Tension. Selected Studies in Scientific Tradition and Change. Chicago
(USA): University of Chicago Press; 1977.
[29] Kuhn TS. Black-Body Theory and the Quantum Discontinuity. 2nd ed. Chicago (USA):
University of Chicago Press; 1978.
[30] Lakatos I, Musgrave A. Problems in the Philosophy of Science. Amsterdam (Holland): North
Holland; 1965.
[31] Lakatos I, Musgrave A. Criticism and the Growth of Knowledge. Cambridge (UK): Cam-
bridge University Press; 1970.
[32] Lakatos I. Proofs and Refutations. Cambridge (UK): Cambridge University Press; 1976.
[33] Lakatos I. The Methodology of Scientific Research. Philosophical Papers, I. Cambridge (UK):
Cambridge University Press; 1978.
[34] Lakatos I. Mathematics, Science and Epistemology. Philosophical Papers, II. Cambridge
(UK): Cambridge University Press; 1978.
[35] Feyerabend PK. Explanation, reduction and empiricism. Minessota (USA): University of
Minessota; 1962.
[36] Feyerabend PK. Against Method. 3rd ed. London (UK): Verso; 1993. ISBN 0-86091-646-4.
[37] Feyerabend PK. Rationalism and the Rise of Science. London (UK): Cambridge University
Press; 1979.
[38] Feyerabend PK. Philosophical Papers, I: Rationalism and the Scientific Method. Cambridge
(UK): Cambridge University Press; 1981.
[39] Feyerabend PK. Philosophical Papers, II: Problems of Empiricism. Cambridge (UK): Cam-
bridge University Press; 1981.
[40] Feyerabend PK. Realism, Rationalism & Scientific Method. Philosophical Papers. Volume I.
Cambridge (USA): Cambridge University Press; 1981. ISBN 0-521-22897-2.
[41] Feyerabend PK. Farewell to Reason. London (UK): Verso; 1987. ISBN 0-86091-896-3.
[42] Argimón Pallás JM, Jiménez Villa J. Métodos de investigación aplicados a la Atención Pri-
maria de Salud. Barcelona: Doyma; 1991.
[43] Hulley SB, Cummings SR, Browner WS, Newman TB, Hearst N. Diseño de la investigación
clı́nica. Un enfoque epidemiológico. Barcelona: Doyma; 1993.
[44] Hulley SB, Cummings SR, Browner WS, Grady D, Hearst N, Newman TB. Designing Cli-
nical Research: An Epidemiological Approach. 2nd ed. Philadelphia: Lippincott Williams &
Wilkins; 2001.
[45] Redondo-Figuero CG, Santamarı́a-Pablos A, Redondo-OrtÌz CG. Aspectos éticos en Inves-
tigación Clı́nica. Pharm Care Esp. 2015;17(4):482–493.
[46] The Swiss Clinical Trial Organisation and the Swiss Ethics Committees on research involving
humans (swissethics). Research with human subjects. A manual for practitioners (second
edition). Bern, Swisse; 2015. Swiss Academy of Medical Sciences (SAMS).
[47] Hulley SB, Cummings SR, Browner WS, Grady DG, Newman TB. Designing clinical re-
search. 4th ed. Lippincott Williams & Wilkins; 2013.

BIBLIOGRAFÍA 393
[48] Altman DG. Statistics and ethics in medical research. III How large a sample? BMJ.
1980;281:1336–1338.
[49] Jennings R. Edición especial Microsoft Access 2000. Madrid: Prentice Hall; 1999.
[50] Courter G, Marquis A. La biblia de Excel 2002. Madrid: Anaya; 2001.
[51] Viescas JL. Guı́a completa de Microsoft Access97. Madrid: McGraw-Hill; 1997.
[52] Dobson R. Programación avanzada con Microsoft Access. Madrid: MaGraw-Hill; 2000.
[53] SPSS Inc. SPSS Base 7.5 Syntax Reference Guide. Chicago: SPSS; 1997.
[54] Ioannidis JPA. Why most published research findings are false. PLoS Med. 2005;2(8):e124.
[55] Altman DG. Statistical reviewing for medical journals. Stat Med. 1998;17:2661–2674.
[56] Bland M. An introduction to medical statistics. 3rd ed. Oxford: Oxford University Press;
2000.
[57] Ercan I, Yazici B, Yang Y, Ozkaya G, Cangur S, Ediz B, et al. Misusage of statistics in medical
research. Eur J Gen Med. 2007;4:128–134.
[58] Altman DG. The scandal of poor medical research. BMJ. 1994;308:283–284.
[59] Altman DG. Transparent reporting of trials is essential. Am J Gastroenterol. 2013;108:1231–
1235.
[60] Lang TA, Altman DG. Basic Statistical Reporting for Articles Published in Biomedical Jour-
nals: The ı̀Statistical Analyses and Methods in the Published Literatureı̂ or The SAMPL Gui-
delinesı̂. In: Smart P, Maisonneuve H, Polderman A, editors. Science Editors’Handbook.
European Association of Science Editors; 2013. .
[61] Cobos-Carbó A, Augustovski F. Declaración CONSORT 2010: actualización de la lista de
comprobación para informar ensayos clı́nicos aleatorizados de grupos paralelos. Med Clin
(Barc). 2011;137:213–215.
[62] Des Jarlais DC, Lyles C, Crepaz N, TRENDG. Improving the reporting quality of nonran-
domized evaluations of behavioral and public health interventions: the TREND statement.
Am J Public Health. 2004;94(3):361–366.
[63] von Elm E, Altman DG, Egger M, Pocock SJ, Gøtzsche PC, Vandenbroucke JP, et al. The
Strengthening the Reporting of Observational Studies in Epidemiology (STROBE) State-
ment: guidelines for reporting observational studies. Int J Surg. 2014 Dec;12(12):1495–1499.
Available from: http://dx.doi.org/10.1016/j.ijsu.2014.07.013.
[64] Gutiérrez-Dı́ez MC, Redondo-Figuero C. La investigación es una necesidad, no una opción.
Emergencias. 2006;18:129–130.
[65] Villanueva J. La investigación cientı́fica y la problemática de la industria farmacéutica. Ars
Pharmaceutica. 2003;44:281–301.
[66] Gutiérrez-Dı́az MC, Santamarı́a-Pablos A, Garcı́a-Benaite DD, Redondo-Figuero C. Razones
para investigar: motivación y reconocimiento. SEMERGEN. 2007;33:111–112.
[67] Redondo-Figuero CG. Aspectos metodológicos básicos en investigación (Investigar en Aten-
ción Primaria). Pediatr Integral. 2012;16:183 (9 pages).
[68] Redondo-Figuero CG. La investigación en la adolescencia. In: Redondo-Figuero CG, Galdó-
Muñoz G, Garcı́a-Fuentes M, editors. Atención al Adolescente. Santander (España): Univer-
sidad de Cantabria; 2008. p. 61–71.
[69] Bacon F. La Gran Restauración (Novum Organum). TraducciÛn de miguel ángel granada
martı́nez ed. Tecnos; 2002. ISBN: 978-84-309-5281-6.
[70] Redondo-Figuero CG. Aspectos metodológicos básicos en Investigación. In: Martı́nez-
Suárez V, editor. Manual de Iniciación a la Investigación en Pediatrı́a de Atención Primaria.
Ergón; 2011. p. 23–48.
[71] Howard Hughes Medical Institute, Burroughs Wellcome Fund. Making the Right Moves.
A Practical Guide to Scientific Management for Postdocs and New Faculty. 2nd ed. North
Carolina (USA): BWF-HHMI; 2006.
[72] Lee A, Dennis C, Campbell P. Nature’s guide for mentors. Nature. 2007;447(7146):791–797.
Available from: http://dx.doi.org/10.1038/447791a.
[73] Yewdell JW. How to succeed in science: a concise guide for young biomedical scientists.
Part I: taking the plunge. Nat Rev Mol Cell Biol. 2008;9(5):413–416. Available from: http:
//dx.doi.org/10.1038/nrm2389.

394 BIBLIOGRAFÍA
[74] Yewdell JW. How to succeed in science: a concise guide for young biomedical scientists. Part
II: making discoveries. Nat Rev Mol Cell Biol. 2008;9(6):491–494. Available from: http:
//dx.doi.org/10.1038/nrm2390.
[75] Sambunjak D, Marusić A. Mentoring: what’s in a name? JAMA. 2009;302(23):2591–2592.
Available from: http://dx.doi.org/10.1001/jama.2009.1858.
[76] van der Weijden I, Belder R, van Arensbergen P, van den Besselaar P. How do young tenured
professors benefit from a mentor? Effects on management, motivation and performance.
High Educ. 2015;69:275–287.
[77] Olaussen A, Reddy P, Irvine S, Williams B. Peer-assisted learning: time for nomenclature
clarification. Med Educ Online. 2016;21:30974.
[78] Rolfe A. The mentor’s role. Korean J Med Educ. 2016;28(2):243–244. Available from: http:
//dx.doi.org/10.3946/kjme.2016.37.
[79] Smith R. The trouble with medical journals. J R Soc Med. 2006;99(3):115–119.
[80] Ioannidis JPA. How to make more published research true. PLoS Med. 2014;11(10):e1001747.
[81] Macleod MR, Michie S, Roberts I, Dirnagl U, Chalmers I, Ioannidis JPA, et al. Biomedical
research: increasing value, reducing waste. Lancet. 2014 Jan;383(9912):101–104. Available
from: http://dx.doi.org/10.1016/S0140-6736(13)62329-6.
[82] Chalmers I, Bracken MB, Djulbegovic B, Garattini S, Grant J, Gülmezoglu AM, et al.
How to increase value and reduce waste when research priorities are set. Lan-
cet. 2014 Jan;383(9912):156–165. Available from: http://dx.doi.org/10.1016/
S0140-6736(13)62229-1.
[83] Chan AW, Song F, Vickers A, Jefferson T, Dickersin K, Gøtzsche PC, et al. Increasing value
and reducing waste: addressing inaccessible research. Lancet. 2014 Jan;383(9913):257–266.
Available from: http://dx.doi.org/10.1016/S0140-6736(13)62296-5.
[84] Moher D, Glasziou P, Chalmers I, Nasser M, Bossuyt PMM, Korevaar DA, et al. In-
creasing value and reducing waste in biomedical research: who’s listening? Lan-
cet. 2016 Apr;387(10027):1573–1586. Available from: http://dx.doi.org/10.1016/
S0140-6736(15)00307-4.
[85] Judson HF. The Great Betrayal: Fraud in Science. Orlando, FL (USA): HarcourtBooks; 2004.
ISBN: 978-0151008773.
[86] Becker RA. A Brief History of S. In: Dirschedl P, Ostermann R, editors. Computational
Statistics: Papers Collected on the Occasion of the 25th Conference on Statistical Computing
at Schloss Reisenburg. Heilderberg: Physica-Verlag; 1994. p. 81–110.
[87] Becker RA, Chambers JM. S: An Interactive Environment for Data Analysis and Graphics.
Pacific Grove, CA (USA): Wadsworth & Brooks/Cole.; 1984. ISBN 0-534-03313-X.
[88] Becker RA, Chambers JM, Wilks AR. The New S Language: A Programming Environment
for Data Analysis and Graphics. Pacific Grove, CA, USA: Wadsworth & Brooks/Cole.; 1988.
ISBN 0-534-09192-X.
[89] Chambers JM, Hastie TJ. Statistical Models in S. Pacific Grove, CA (USA): Wadsworth &
Brooks/Cole.; 1991. ISBN 0-412-05291-1.
[90] Becker RA, Chambers JM. Extending the S System. Pacific Grove, CA (USA): Wadsworth &
Brooks/Cole.; 1985. ISBN 0-534-05016-6.
[91] Chambers JM. Programming with Data. New York: Springer; 1998. ISBN 0-387-98503-4.
[92] Ihaka R, Gentleman R. R: A Language for Data Analysis and Graphics. Journal of Compu-
tational and Graphical Statistics. 1996;5(3):299–314.
[93] R Development Core Team. R: A Language and Environment for Statistical Computing.
Vienna, Austria; 2009. ISBN 3-900051-07-0.
[94] Gentelman R. R Programming for Bioinformatics. Boca Raton, FL (USA): Chapman & Hall
/ CRC Press; 2009. ISBN: 978-1-4200-6367-7.
[95] Dalgaard P. Introductory Statistics with R. 2nd ed. New York (USA): Springer; 2008.
[96] Fox J, Weisberg S. An R Companion to Applied Regression. 2nd ed. Thousand Oaks, CA,
USA: Sage Publications; 2011. ISBN 978-1-4129-7514-8.
[97] Everitt BS, Hothorn I. A Handbook of Statistical Analyses Using R. 2nd ed. Boca Raton, FL
(USA): Chapman & Hall / CRC Press; 2010. ISBN 978-1-4200-7933-3.

BIBLIOGRAFÍA 395
[98] Salas C. ¿ Por qué comprar un programa estadı́stico si existe R? Ecologı́a Austral. 2008
Agosto;18:223–231.
[99] Oliden PE. ¿ Existe vida más allá del SPSS? Descubre R. Psicothema. 2009;21:652–655.
[100] Gentleman RC, Carey VJ, Bates DM, Bolstad B, Dettling M, Dudoit S, et al. Bioconductor:
open software development for computational biology and bioinformatics. Genome Biol.
2004;5(10):R80. Available from: http://dx.doi.org/10.1186/gb-2004-5-10-r80.
[101] Maindonald J, Braun J. Data Analysis and Graphics Using R. An Example-Based Approach.
2nd ed. Cambridge Series in Statistical and Probabilistic Mathematics. Cambridge: Cambrid-
ge University Press; 2007. ISBN 978-0-521-86116-8.
[102] Venables WN, Ripley BD. Modern Applied Statistics with S. 4th ed. New York (USA):
Springer; 2002. ISBN 0-387-95457-0.
[103] Murrell P. R Graphics. Boca Raton, FL (USA): Chapman & Hall / CRC Press; 2006. ISBN
1-58488-486-X.
[104] Baldi P, Brunak S. Bioinformatics. The Machine Learning Approach. MIT Press; 2001.
[105] Rodriguez-Acevedo AJ, Smith RA, Roy B, Sutherland H, Lea RA, Frith A, et al. Genetic
association and gene expression studies suggest that genetic variants in the SYNE1 and TNF
genes are related to menstrual migraine. J Headache Pain. 2014;15:62. Available from: http:
//dx.doi.org/10.1186/1129-2377-15-62.
[106] Afgan E, Sloggett C, Goonasekera N, Makunin I, Benson D, Crowe M, et al. Geno-
mics Virtual Laboratory: A Practical Bioinformatics Workbench for the Cloud. PLoS One.
2015;10(10):e0140829. Available from: http://dx.doi.org/10.1371/journal.pone.
0140829.
[107] Loraine AE, Blakley IC, Jagadeesan S, Harper J, Miller G, Firon N. Analysis and visualization
of RNA-Seq expression data using RStudio, Bioconductor, and Integrated Genome Browser.
Methods Mol Biol. 2015;1284:481–501. Available from: http://dx.doi.org/10.1007/
978-1-4939-2444-8_24.
[108] Angione C, Conway M, Lió P. Multiplex methods provide effective integration of multi-
omic data in genome-scale models. BMC Bioinformatics. 2016;17 Suppl 4:83. Available from:
http://dx.doi.org/10.1186/s12859-016-0912-1.
[109] Perry BR, Assis R. CDROM: Classification of Duplicate gene RetentiOn Mechanisms.
BMC Evol Biol. 2016;16(1):82 (4 pages). Available from: http://dx.doi.org/10.1186/
s12862-016-0644-x.
[110] Broman KW, Keller MP, Broman AT, Kendziorski C, Yandell BS, Sen S, et al. Identification
and Correction of Sample Mix-Ups in Expression Genetic Data: A Case Study. G3 (Bethes-
da). 2015 Oct;5(10):2177–2186. Available from: http://dx.doi.org/10.1534/g3.115.
019778.
[111] Morgan AP. argyle: An R Package for Analysis of Illumina Genotyping Arrays. G3 (Bethes-
da). 2016;6:281–286.
[112] Turewicz M, Ahrens M, May C, Marcus K, Eisenacher M. PAA: an R/bioconductor package
for biomarker discovery with protein microarrays. Bioinformatics. 2016 May;32(10):1577–
1579. Available from: http://dx.doi.org/10.1093/bioinformatics/btw037.
[113] Schwartz M, Harrell F, Rossini A, Francis I. R: Regulatory Compliance and Validation Issues
A Guidance Document for the Use of R in Regulated Clinical Trial Environments. Vienna,
Austria (EU): The R Foundation for Statistical Computing; 2014.
[114] Chambers JM, Lang DT. Object-Oriented Programming in R. R News. 2001;1(3):17–19.
[115] Fox J. An R and S-Plus Companion to Applied Regression. Thousand Oaks, CA, USA: Sage
Publications; 2002. ISBN 0-761-92279-2.
[116] R Core Team. R: A Language and Environment for Statistical Computing. Vienna, Austria;
2016. Available from: https://www.R-project.org/.
[117] Venables WN, Smith DM, the R Development Core Team. An Introduction to R. Notes on R:
A Programming Environment for Data Analysis and Graphics. Version 2.10.1 (2009-12-14),
101 pages. Vienna, Austria; 2009. ISBN 3-900051-12-7.
[118] RStudio Team. RStudio: Integrated Development Environment for R. Boston, MA; 2015.
Available from: http://www.rstudio.com/.

396 BIBLIOGRAFÍA
[119] Verzani J. Getting Started with RStudio. Sebastopol, CA (USA): O’Reilly; 2011. ISBN: 978-1-
449-30903-9.
[120] Fox J, are grateful to Douglas Bates SWW, Firth D, Friendly M, Gorjanc G, Graves S, et al..
car: Companion to Applied Regression; 2010. R package version 2.0-2. Available from:
http://CRAN.R-project.org/package=car.
[121] Jr FEH, with contributions from many other users. Hmisc: Harrell Miscellaneous; 2010.
R package version 3.8-2. Available from: http://CRAN.R-project.org/package=
Hmisc.
[122] Verzani J. UsingR: Data sets for the text Üsing R for Introductory Statistics”; 2010. R package
version 0.1-13. Available from: http://CRAN.R-project.org/package=UsingR.
[123] Meyer D, Zeileis A, Hornik K. vcd: Visualizing Categorical Data. R package version 1.4-1.;
2015.
[124] Signorell A, et al . DescTools: Tools for Descriptive Statistics; 2016. R package version 0.99.17.
Available from: http://CRAN.R-project.org/package=DescTools.
[125] Maindonald J, Braun WJ. Data Analysis and Graphics Using R - an Example-Based Ap-
proach. 3rd ed. Cambridge (UK): Cambridge University Press; 2010. ISBN-13 978-0-521-
76293-9.
[126] Gross J. nortest: Tests for Normality; 2010. R package version 1.0.
[127] with contributions by Wei Liu MH. binomSamSize: Confidence intervals and sample size
determination for a binomial proportion under simple random sampling and pooled sam-
pling; 2009. R package version 0.1-2. Available from: http://CRAN.R-project.org/
package=binomSamSize.
[128] Zhang B, Bilder C, Biggerstaff B, Schaarschmidt F. binGroup: Evaluation and experimental
design for binomial group testing; 2010. R package version 1.0-6. Available from: http:
//CRAN.R-project.org/package=binGroup.
[129] many thanks to V Winston KA, Roberts D. asbio: A collection of statistical tools for biolo-
gists; 2010. R package version 0.3-12. Available from: http://CRAN.R-project.org/
package=asbio.
[130] Robin X, Turck N, Hainard A, Tiberti N, Lisacek F, Sanchez JC, et al.. display and analyze
ROC curves: Tools for visualizing, smoothing and comparing receiver operating characte-
ristic (ROC curves). (Partial) area under the curve (AUC) can be compared with statistical
tests based on U-statistics or bootstrap. Confidence intervals can be computed for (p)AUC
or ROC curves.; 2010. R package version 1.3.1.
[131] Lemon J, Grosjean P. prettyR: Pretty descriptive stats.; 2010. R package version 1.8-1. Avai-
lable from: http://CRAN.R-project.org/package=prettyR.
[132] Carstensen B, Plummer M, Laara E, et al MH. Epi: A package for statistical analysis in epi-
demiology.; 2010. R package version 1.1.15. Available from: http://CRAN.R-project.
org/package=Epi.
[133] Newcombe RG. Interval estimation for the difference between independent proportions:
comparison of eleven methods. Stat Med. 1998;17:873–890.
[134] Stevenson M, Nunes T, Sanchez J, , Thornton R. epiR: Functions for analysing epidemiolo-
gical data; 2010. R package version 0.9-26. Available from: http://CRAN.R-project.
org/package=epiR.
[135] Rotondi MA. epibasix: Elementary Epidemiological Functions for a Graduate
Epidemiology-Biostatistics Course; 2009. R package version 1.1. Available from:
http://CRAN.R-project.org/package=epibasix.
[136] Chongsuvivatwong V. epicalc: Epidemiological calculator; 2010. R package version 2.11.1.0.
Available from: http://CRAN.R-project.org/package=epicalc.
[137] Chongsuvivatwong V. Analysis of epidemiological data using R and Epicalc. McNeil E,
editor. Songkhla, Thailand: Chanmuang Press; 2008. ISBN: 978-974-11-4921-6.
[138] Groendyke C, Welch D, Hunter DR. epinet: A collection of epidemic/network-related
tools; 2010. R package version 0.0-8. Available from: http://CRAN.R-project.org/
package=epinet.
[139] Aragon T. epitools: Epidemiology Tools; 2010. R package version 0.5-6. Available from:
http://CRAN.R-project.org/package=epitools.

BIBLIOGRAFÍA 397
[140] Lai CC, Sung MI, Liu HH, Chen CM, Chiang SR, Liu WL, et al. The Ratio of Partial Pressure
Arterial Oxygen and Fraction of Inspired Oxygen 1 Day After Acute Respiratory Distress
Syndrome Onset Can Predict the Outcomes of Involving Patients. Medicine (Baltimore).
2016;95(14):e3333.
[141] Du Bois D, Du Bois EF. A formula to estimate the approximate surface area if height and
weight be know. Arch Intern Med. 1916;17:863–871.
[142] Mosteller RD. Simplified calculation of body-surface area. N Engl J Med. 1987;317:1098.
[143] Cobb JR. Outline for the study of scoliosis. Instructional course lectures. The American Aca-
demy of Orthopedic Surgeons. The American Academy of Orthopedic Surgeons. 1948;5:261–
275.
[144] Cohen Y, Cohen JY. Statistics and Data with R. An Applied Approach Through Examples.
Chichester (UK): Wiley; 2008. ISBN: 978-0-470-75805-2.
[145] Adler J. R in a Nutshell. O’Reilly; 2010.
[146] Matloff N. The Art of Programming. A Tour of Statistical Software Design. San Francisco,
CA (USA): no starch press; 2011. ISBN-13: 978-1-59327-384-2.
[147] Bååth R. The State of Naming Conventions in R. The R Journal. 2012;4(2):74–75. Availa-
ble from: http://journal.r-project.org/archive/2012-2/RJournal_2012-2_
Baaaath.pdf.
[148] Wickham H. Advanced R. The R series. Boca Raton, FL (USA): CRC Press (Chapmana &
Hall); 2014. ISBN: 978-1-4665-8696-3.
[149] Johnson PE. R Style. An Rchaeological Commentary;.
[150] Jones O, Maillardet R, Robinson A. Introduction to Scientific Programming and Simulation
Using R. 1st ed. Bopca Raton, FL (USA): CRC Press (Chapmana & Hall); 2009. ISBN: 978-1-
4200-6872-6.
[151] Venables WN, Ripley BD. S Programming. Statistics and Computing. New York: Springer-
Verlag; 2000. ISBN: 0-387-98966-8.
[152] Crawley MJ. The R Book. Chichester (UK): John Wiley & Sons; 2007. ISBN-13: 978-0-470-
51024-7.
[153] Albert J, Rizzo M. R by Example. Use R!. New York (USA): Springer; 2012. ISBN 978-1-4614-
1364-6.
[154] Cárdenas ML, Cornish-Bowden A. Rounding error, an unexpected fault in the output
from a recording spectrophotometer: implications for model discrimination. Biochem J.
1993;292:37–40.
[155] Garcı́a-Berthou E, Alcaraz C. Incongruence between test statistics and P values in medical
papers. BMC Med Res Methodol. 2004 May;4:13. Available from: http://dx.doi.org/
10.1186/1471-2288-4-13.
[156] Jeng M. Error in statistical tests of error in statistical tests. BMC Med Res Methodol.
2006;6:45. Available from: http://dx.doi.org/10.1186/1471-2288-6-45.
[157] Emmerson AJ, Roberts SA. Rounding of birth weights in a neonatal intensive care unit over
20 years: an analysis of a large cohort study. BMJ open. 2013;3(12):e003650 (5 pages).
[158] Kalinina EA. The most precise computations using Euler’s method in standard floating-
point arithmetic applied to modelling of biological systems. Comput Methods Programs
Biomed. 2013 Aug;111(2):471–479. Available from: http://dx.doi.org/10.1016/j.
cmpb.2013.04.001.
[159] Goede SL, Leow MKS. General error analysis in the relationship between free thyroxine and
thyrotropin and its clinical relevance. Comput Math Methods Med. 2013;p. 831275 (7 pages).
Available from: http://dx.doi.org/10.1155/2013/831275.
[160] Braun WJ, Murdoch DJ. A First Course in Statistical Programming with R. Cambridge:
Cambridge University Press; 2007. ISBN 978-0521872652.
[161] Chambers JM. Software for Data Analysis: Programming with R. New York (USA): Springer;
2008. ISBN 978-0-387-75935-7.
[162] Chambers JM. Object-Oriented Programming, Functional Programming and R. Statistical
Science. 2014;29(2):167–180.

398 BIBLIOGRAFÍA
[163] McConnell S. Code Complete: A practical handbook of software construction. 2nd ed.
Redmond. Washington (USA): Microsoft Press; 2004.
[164] Martı́nez Salas J. Elementos de Matemáticas. 3rd ed. Andrés Martı́n; 1969.
[165] Stewart J. Calculus: concepts and contexts. 2nd ed. California (USA): Thompson Learning;
2001.
[166] Larson RE, Hostetler RP. Cálculo y Geometrı́a Analı́tica. Madrid: McGraw-Hill; 1992.
[167] Crawley MJ. The R Book. 2nd ed. Chichester (UK): John Wiley & Sons; 2013. ISBN 978-0-
470-97392-9.
[168] Harrell FE, Dupont C, et al . Hmisc: Harrell Miscellaneous. R package version 3.14-6. Cran-R;
2014.
[169] Chongsuvivatwong V. Epicalc: Epidemiological calculator. R package version 2.15.1.0. Thai-
land: Cran-R; 2012.
[170] Aragón TJ. Applied Epidemiology Using R. The author; 2013.
[171] Breslow NE, Day NE. Statistical Methods in Cancer Research. 1: The Analysis of Case-
Control Studies. IARC Lyon / Oxford University Press; 1980.
[172] Verzani J. Using R for Introductory Statistics. 1st ed. Boca Raton, Florida: Chapman &
Hall/CRC; 2005. ISBN: 1-58488-4509.
[173] Hjalmarson A, Elmfeldt D, Herlitz J, Holmberg S, Málek I, Nyberg G, et al. Effect on morta-
lity of metoprolol in acute myocardial infarction. A double-blind randrandom trial. Lancet.
1981;2(8251):823–827.
[174] Martı́nez Calvo MC, Pérez de Vargas A. Métodos matemáticos en Biologı́a. Madrid: Centro
de Estudios Ramón Areces; 1993.
[175] Rothman KJ, Greeland S. Modern Epidemiology. 2nd ed. Philadelphia (USA): Lippincott;
1998.
[176] Borbolla R, Sanz P. Álgebra lineal y teorı́a de matrices. Madrid, España: Prentice Hall; 1998.
ISBN: 84-8322-008-3.
[177] Armitage P, Berry G, Matthews JNS. Statistical Methods in Medical Research. 4th ed. Mas-
sachusetts (USA): Blackwell Science; 2002. ISBN: 978-0-6320-5257-8.
[178] Chongsuvivatwong V. Analysis of Epidemiological Data Using R and Epicalc. Prince of
Songkla University, Hat Yai, Thailand: World Health Organization; 2007.
[179] Jewell NP. Statistics for Epidemiology. Boca Raton, Florida (USA): Chapman & Hall / CRC
Press; 2009. ISBN 0-203-59461-4.
[180] Olsen J, Christensen K, Murray J, Ekbom A. An Introduction to Epidemiology for Health
Professionals. New York (USA): Springer; 2010. ISBN 978-1-4419-1496-5.
[181] Coghlan A. A Little Book of R For Biomedical Statistics. Cambridge (UK): Parasite Genomics
Group, Wellcome Trust Sanger Institute; 2014.
[182] Selvin S. Statistical Tools for Epidemiologic ResearchFLPxxx2003FLPxxx2003. Oxford (UK):
Oxford University Press; 2011. ISBN 978-0-19-975596-7.
[183] Ripley BD, Hornik K. Date-Time Classes. R-News. 2001;1/2:8–12.
[184] Grolemund G, Wickham H. Dates and Times Made Easy with lubridate. Journal of Statistical
Software. 2011;40(3):25 pages.
[185] Pruim R, Kaplan DT, Horton NJ. mosaic: Project MOSAIC Statistics and Mathematics
Teaching Utilities; 2016. R package version 0.14.4. Available from: https://CRAN.
R-project.org/package=mosaic.
[186] Fox J. Frames, Environments, and Scope in R and S-PLUS. Appendix to An R and S-PLUS
Companion to Applied Regression. Car. 2002;.
[187] Zeileis A, Hornik K, Murrell P. Escaping RGBland: Selecting Colors for Statistical Graphics.
Computational Statistics and Data Analysis. 2009;53:3259–3270.
[188] Zhou L, Braun WJ. Fun with the R Grid Package. Journal of Statistics Education.
2010;18(3):1–35.
[189] Sarkar D. Lattice. Multivariate Data Visualization with R. Use R. USA: Springer; 2008. ISBN:
978-0-387-75968-5.

BIBLIOGRAFÍA 399
[190] Tennekes M, de Jonge E, Daas PJH. Visualizing and Inspecting Large Datasets with Table-
plots. Journal of Data Science. 2013;11:43–58.
[191] Tennekes M, de Jonge E. tabplot: Tableplot, a Visualization of Large Datasets; 2016. R pac-
kage version 1.3. Available from: https://CRAN.R-project.org/package=tabplot.
[192] Cleveland WS. Graphical methods for data presentation: Full scale breaks, dot charts, and
multibased logging. The American Statistician. 1981;38(4):270–280.
[193] Cleveland WS, McGill R. Graphical Perception: Theory, Experimentation, and Application
to the Development of Graphical Methods. Journal of the American Statistical Association.
1984;79:531–554.
[194] Cleveland WS. Visualizing Data. Summit, New Jersey: Hobart Press; 1993. ISBN: 0-9634884-
0-6.
[195] Cleveland WS. The Elements of Graphing Data. 2nd ed. Summit, New Jersey (USA): Hobart
Press; 1994. ISBN: 0-9634884-1-4.
[196] Hartigan JA, Kleiner B. A mosaic of television ratings. Tha American Statician. 1984;38:32–
35.
[197] Friendly M. A brief history of the mosaic plot. 2001;.
[198] Friendly M, Meyer D. Discrete Data Analysis with R: Visualization and Modeling Techni-
ques for Categorical and Count Data. Boca Raton, FL. (USA): Chapman & Hall/CRC; 2016.
ISBN 978-1-4987- 2583-5.
[199] Few S. Are mosaic plots worthwhile? Visual Business Intelligence Newsletter. 2014;(1):1–14.
[200] Unlu A, Sargin A, Viehrig M. Mosaics for visualizing knowledge structures. Journal of Data
Science. 2013;11:451–478.
[201] Friendly M. A fourfold display for 2 by 2 by k tables. Technical Report 217. Psychology
Departamente. York University; 1994.
[202] Horváth A, Páll N, Molnár K, Kováts T, Surján G, Vicsek T, et al. A nationwide study of the
epidemiology of relapsing polychondritis. Clin Epidemiol. 2016;8:211–230. Available from:
http://dx.doi.org/10.2147/CLEP.S91439.
[203] Aimone AM, Brown PE, Zlotkin SH, Cole DC, Owusu-Agyei S. Geo-spatial factors as-
sociated with infection risk among young children in rural Ghana: a secondary spa-
tial analysis. Malar J. 2016;15:349. Available from: http://dx.doi.org/10.1186/
s12936-016-1388-1.
[204] Pigott DM, Millear AI, Earl L, Morozoff C, Han BA, Shearer FM, et al. Updates to the
zoonotic niche map of Ebola virus disease in Africa. Elife. 2016;5. Available from: http:
//dx.doi.org/10.7554/eLife.16412.
[205] Moyes CL, Shearer FM, Huang Z, Wiebe A, Gibson HS, Nijman V, et al. Predicting the geo-
graphical distributions of the macaque hosts and mosquito vectors of Plasmodium knowlesi
malaria in forested and non-forested areas. Parasit Vectors. 2016;9(1):242. Available from:
http://dx.doi.org/10.1186/s13071-016-1527-0.
[206] Insaf TZ, Talbot T. Identifying areas at risk of low birth weight using spatial epidemiology:
A small area surveillance study. Prev Med. 2016 Jul;88:108–114. Available from: http:
//dx.doi.org/10.1016/j.ypmed.2016.03.019.
[207] code by Richard A Becker OS, version by Ray Brownrigg Enhancements by Thomas P Min-
ka ARWR, Deckmyn A. maps: Draw Geographical Maps; 2016. R package version 3.1.0.
Available from: https://CRAN.R-project.org/package=maps.
[208] Becker RA, Cleveland WS, Shyu MJ. The visual design and control of trellis display. Juournal
of Computational and Graphical Statistics. 1996;5:123–155.
[209] Sarkar D, Le Meur N, Gentleman R. Using flowViz to visualize flow cytometry data. Bio-
informatics. 2008 Mar;24(6):878–879. Available from: http://dx.doi.org/10.1093/
bioinformatics/btn021.
[210] Sun X, Li J. PKreport: report generation for checking population pharmacokinetic model
assumptions. BMC Med Inform Decis Mak. 2011;11:31. Available from: http://dx.doi.
org/10.1186/1472-6947-11-31.
[211] Gu Z, Eils R, Schlesner M. gtrellis: an R/Bioconductor package for making genome-level
Trellis graphics. BMC Bioinformatics. 2016;17:169. Available from: http://dx.doi.org/
10.1186/s12859-016-1051-4.

400 BIBLIOGRAFÍA
[212] Hintze JL, Nelson RD. Violin plots: a box plot-density trace synergism. The American Sta-
tistician. 1998;52(2):181–184.
[213] Kampstra P. Beanplot: a boxplot alternative for visual comparison of distribution. Journal
of Statistical Software. 2008;28:9 pages.
[214] Tufte ER. The Visual Display of Quantitative Information. 2nd ed. Cheshire, Connecticut
(USA): Graphic Press; 2001. ISBN-13: 978-0961392147.
[215] van Belle G, Fisher LD, Heagerty PJ, Lumley T. Biostatistics. A Methodology for the Health
Sciences. 2nd ed. Hoboken, New Jersey (USA): John Wiley & Sons; 2004. ISBN 0-471-03185-2.
[216] Cleveland WS. The Elements of Graphing Data. 1st ed. Monterey, California (USA): Wads-
worth; 1985. ISBN 0-534-03730-5.
[217] Friendly M, Denis D. The early origins and development of the scatterplot. J Hist Behav Sci.
2005;41(2):103–130. Available from: http://dx.doi.org/10.1002/jhbs.20078.
[218] Murdoch D, Chow ED. ellipse: Functions for drawing ellipses and ellipse-like confidence
regions; 2013. R package version 0.3-8. Available from: https://CRAN.R-project.org/
package=ellipse.
[219] Sarkar D, Andrews F. latticeExtra: Extra Graphical Utilities Based on Lattice; 2016. R
package version 0.6-28. Available from: https://CRAN.R-project.org/package=
latticeExtra.
[220] for R by Ray Brownrigg DMP, Minka TP, transition to Plan 9 codebase by Roger Bivand.
mapproj: Map Projections; 2015. R package version 1.2-4. Available from: https://CRAN.
R-project.org/package=mapproj.
[221] Wickham H. ggplot2. Elegant Graphics for Data Analysis. Use R!. New York: Springer; 2009.
ISBN 978-0-387-98140-6.
[222] Wickham H. A Layered Grammar of Graphics. Journal of Computational and Graphical
Statistics. 2010;19:3–28.
[223] Sun X, Wu K, Cook D. PKgraph: an R package for graphically diagnosing population phar-
macokinetic models. Comput Methods Programs Biomed. 2011 Dec;104(3):461–471. Availa-
ble from: http://dx.doi.org/10.1016/j.cmpb.2011.03.016.
[224] Ito K, Murphy D. Application of ggplot2 to Pharmacometric Graphics. CPT Pharmacome-
trics Syst Pharmacol. 2013;2:e79. Available from: http://dx.doi.org/10.1038/psp.
2013.56.
[225] Wilkinson L. The Grammar of Graphics. New York (USA): Springer; 2005. ISBN-13: 978-
0387-24544-7.
[226] Chasalow S. combinat: combinatorics utilities; 2012. R package version 0.0-8. Available from:
https://CRAN.R-project.org/package=combinat.
[227] Kassambara A. ggcorrplot: Visualization of a Correlation Matrix using ’ggplot2’; 2016.
R package version 0.1.1. Available from: https://CRAN.R-project.org/package=
ggcorrplot.
[228] Pebesma EJ, Bivand RS. Classes and methods for spatial data in R. R News. 2005;5(2):9–13.
Available from: http://CRAN.R-project.org/doc/Rnews/.
[229] Bivand RS, Pebesma EJ, GÛmez-Rubio V. Applied Spatial Data Analysis with R. Use R!.
New York (USA): Springer; 2008. ISBN 978-0-387-78170-9.
[230] Bivand RS, Pebesma EJ, GÛmez-Rubio V. Applied Spatial Data Analysis with R. 2nd ed.
New York (USA): Springer; 2013. Available from: http://.www.asdar-book.org/.
[231] Navarro DJ. Learning statistics with R: A tutorial for psychology students and other begin-
ners. University of Adelaide; 2013.
[232] Muenchen RA. R for SAS and SPSS Users. 2nd ed. New York (USA): Springer; 2011. ISBN
978-1-4614-0684-6.
[233] Shapiro SS, Wilk MB. An analysis of variance test for normality (complete samples). Biome-
trika. 1965;52:591–611.
[234] Hain J. Comparison of Common Tests for Normality. Wurzburg, Germany: Julius-
Maximilians-Universitat Wurzburg Institut fur Mathematik und Informatik; 2010.

BIBLIOGRAFÍA 401
[235] Ghasemi A, Zahediasl S. Normality tests for statistical analysis: a guide for non-statisticians.
Int J Endocrinol Metab. 2012;10(2):486–489. Available from: http://dx.doi.org/10.
5812/ijem.3505.
[236] Sturges H. The choice of a class-interval. J Amer Statist Assoc. 1926;21:65–66.
[237] Matloff N, Salzman PJ. The Art of Debugging with GDB, DDD, and Eclipse. No Starch Press;
2008.
[238] Bravington MV. debug: MVB’s debugger for R; 2013. R package version 1.3.1. Available
from: https://CRAN.R-project.org/package=debug.
[239] Booch G, Maksimchuk R, Engle M, Young B, Conallen J, Houston K. Object-oriented
analysis and design with applications. 3rd ed. Addison-Wesley Professional; 2007.
ISBN:9780201895513.
[240] R Development Core Team. R Language Definition. Version 2.10.1 (2009-12-14), 60 pages.
Vienna, Austria; 2009. ISBN 3-900051-13-5.
[241] Dahl OJ, Myhrhaug B, Nygaard K. SIMULA information COMMON BASE LANGUAGE.
Oslo (Norway); 1970.
[242] Kay AC. The Early History of Smalltalk. ACM SIGPLAN Notices. 1993;28(3):1–54.
[243] Kay AC. The Reactive Engine (PhD). University of Utah; 1969.
[244] Goldberg A, Kay A. Smalltalk-72: Instruction Manual. Xerox Corporation; 1976.
[245] Peña R. La programación orientada a objetos; 2010.
[246] Gurarie E. Object-Oriented Programming in R. University of Washington; 2015.
Available from: http://http://faculty.washington.edu/eliezg/teaching/
StatR301/2015/Lecture08_MarkovChainsAndFriends/Lecture08c_OOPinRs_
ForPrinting.pdf.
[247] Uyttendaele N. How to speed up R code: an introduction. Voie du Roman Pays 20, B-
1348 Louvain-la-Neuve, Belgium.; 2015. Available from: https://ai2-s2-pdfs.s3.
amazonaws.com/88aa/fee3c59b7c25dfc708fbbf421caedbb6659a.pdf.
[248] Tierney L. A Byte Code Compiler for R. USA; 2016. Department of Statistics and Actuarial
Science. Available from: http://homepage.divms.uiowa.edu/˜luke/R/compiler/
compiler.pdf.
[249] Mersmann O. microbenchmark: Accurate Timing Functions; 2015. R package version 1.4-2.1.
Available from: https://CRAN.R-project.org/package=microbenchmark.

Índice alfabético
+, 65 as.array(), 85
..., 67 as.character(), 85
.GlobalEnv, 75 as.complex(), 85
.Last.value, 67 as.data.frame(), 85
:, 62 as.difftime(), 196
::, 62 as.double(), 85
:::, 62 as.factor(), 85
;, 65 as.list(), 85
¿, 65 as.logical(), 85
ámbito as.matrix(), 85
léxico, 207 as.numeric(), 85
ángulo de Cobb, 48 as.raw(), 85
árbol de directorios, 31 as.ts(), 85
tab completion, 29 as.vector(), 85
?(), 51 asin(), 48
Arg(), 101 assign(), 94
Conj(), 101 assocplot(), 234
Fazar(), 331 atan(), 48
Fcomplete cases(), 343 attach(), 208
Fdescrip basica(), 329 attr(), 77, 78, 183
Fdiscrepa mdym(), 281 attributes(), 77, 78, 92
Fecu 2g(), 305 autores
Fed n(), 335 Ripley(), 206
Fh(), 340 axis(), 242
Fmedia(), 327 barchart(), 258
Fnormalidad(), 338 barplot(), 220
Fprueba diag(), 345 baseenv(), 206
Fsaludos(), 325 body(), 301
Ftabla diag(), 330 box(), 242
ISOdatetime(), 194 boxplot(), 224
Im(), 101 bwplot(), 255
Mod(), 101 by(), 375
ROC()(), 40 c(), 92
Re(), 101 car::qqPlot(), 226
Sys.Date(), 192 cat(), 88
Sys.time(), 191 cbind(), 151
Sys.timezone()(), 190 cdplot(), 232, 244
UseMethod(), 308 ceiling(), 45
abline(), 240 chisq.test(), 300
abs(), 46 choose(), 46
acos(), 48 ci.pd()(), 40
addmargins(), 171 citation(), 21
aes(), 273 class(), 77, 79, 115
aggregate(), 187, 376 clogistic()(), 40
aperm(), 171, 172 cloud(), 263
apply(), 128, 160, 368 cm.colors(), 217
apropos(), 54, 57 col(), 156
args(), 301 colMeans(), 159
array(), 169 colSums(), 159
arrows(), 240 colnames(), 152
as.Date(), 193 complete.cases(), 186
403
404 ÍNDICE ALFABÉTICO
complex(), 100 if(), 315

contour(), 236 ifelse(), 317
contributors(), 21 image(), 236
corrplot(), 247 integer(), 99
cos(), 48 interaction.plot(), 229
crossprod(), 164 invisible(), 307
cummax(), 113 is.array(), 85
cummin(), 113 is.character(), 85
cumprod(), 113 is.complex(), 85
cumsum(), 113 is.data.frame(), 85
cut(), 122 is.double(), 85
data.frame(), 173 is.factor(), 85
date()(), 192 is.list(), 85
date(), 23 is.logical(), 85
demo(), 21, 57 is.matrix(), 85
density(), 222 is.na(), 115
densityplot(), 253 is.numeric(), 85
det(), 156 is.raw(), 85
detach(), 208 is.ts(), 85
diag(), 156 is.vector(), 85
difftime(), 195 labels(), 121
dim(), 77, 79, 181 lapply(), 145, 370
dimnames(), 152 legend(), 242
dotPlot(), 201 length(), 77, 79, 92
dotchart(), 225 levelplot(), 265
dotplot(), 259 levels(), 120, 121
double(), 99 lgamma(), 46
eapply(), 379 library()(), 35
emptyenv(), 206 library(), 207
environment(), 206, 302 licence(), 21
example(), 54 license(), 21
exp(), 46, 66 lines(), 241
expm1(), 46 list(), 102, 142
facet(), 285 load(), 24
factor(), 118, 119 locator(), 244
factorial(), 46 log(), 46
find(), 57 log10(), 46, 67, 308
floor(), 45 log1p(), 46
for(), 321 log2(), 46
formals(), 300 ls(), 23, 75, 84, 208
fourfoldplot(), 234 ls.str(), 90, 208
ftable(), 136 mapplot(), 266
gamma(), 46 mapply(), 377
geom smooth(), 274 matplot(), 231
getAnywhere(), 360 matrix(), 150
ggplot(), 273 max(), 113
ggtitle(), 273 mean(), 113, 328
gl(), 127 mean.default(), 308
globalenv(), 206 median(), 113
gray(), 217 merge(), 180
grey(), 217 methods(), 309
grid(), 242 microbenchmark(), 385
heatmap(), 238 min(), 113
help()(), 51 mode(), 77, 82, 113
help(), 21 mosaicplot(), 232
help.search(), 52 mtext(), 219, 243
help.start(), 21, 53 na.exclude(), 186
hist(), 221 na.omit(), 186
histogram(), 252 names(), 77, 81, 105, 143, 182
history(), 57 nchar(), 107
identify(), 244 ncol(), 156
if else(), 315 new.env(), 208

ÍNDICE ALFABÉTICO 405
nlevels(), 127 scale shape manual(), 274

nomiss(), 161 scan(), 94
nrow(), 156 scatterplot(), 272
objects(), 75, 84 sd(), 113
ordered(), 121, 125 search()(), 35
outer(), 379 search(), 22, 23, 207
pairs(), 227 searchpaths(), 207
par(), 214 segments(), 242
parent.env(), 209 seq(), 95, 196
paste(), 106 setNames(), 105
persp(), 237 shapiro.test(), 301
pie(), 220 signify(), 45
plot(), 226, 359 sin(), 48
points(), 240 smoothScatter(), 235
polygon(), 241 sort(), 111
print(), 66 source(), 297
prop.table(), 133, 172 spineplot(), 233
psirs(), 261 split(), 371, 374
q(), 23 splom(), 261
qqline(), 226 sqrt(), 46, 67
qqnorm(), 226 stat function(), 283
quantile(), 113 storage.mode(), 77, 83
quit(), 23 str(), 77, 83, 181
range(), 113 stripchart(), 223
rbind(), 151 strsplit(), 107
read.DIF(), 178 structure(), 77, 84
read.arff(), 178 substr(), 107
read.csv(), 177 sum(), 113, 303
read.csv2(), 178 summ(), 57
summary(), 309
read.dbf(), 178
sunflowerplot(), 230
read.dta(), 178
sweep(), 380
read.epiinfo(), 178
system.time(), 383
read.fortran(), 178
t(), 156
read.ftable(), 178
tab1(), 132
read.fwf(), 178
table(), 120, 131, 133
read.mtp(), 178
tabpct(), 134
read.octave(), 178
tan(), 48
read.spss(), 178
tapply(), 128, 374
read.ssd(), 178
terrain.colors(), 217
read.systat(), 178
text(), 219, 243
read.table(), 174 theme(), 281
read.xport(), 178 title(), 243
rect(), 243 tolower(), 107
releven(), 126 topo.colors(), 217
remove(), 75, 116 toupper(), 107
rep(), 97 trunc(), 45
repeat(), 323 twoby2()(), 40
require(), 207 typeof(), 77, 81, 92
rev(), 111 unclass(), 118
rgb(), 217 unlist(), 146
rm(), 75, 112, 209 update(), 203
rnorm(), 46, 331 vapply(), 378
round(), 45 var(), 113
row(), 156 vector(), 98, 99
rowMeans(), 159 vignette(), 55
rowSums(), 159 which(), 109
rownames(), 152 writte(), 297
runif(), 46 xor(), 68
sapply(), 145, 185, 371 xtabs(), 135, 203
save(), 113 xyplot(), 260
save.image(), 23
scale color brewer(), 273 abstracción, 357

access, 9 Sarkar, 251, 260

algoritmos, 19 Selvin, 172
análisis Simonyi, 73
estratificado, 170 Sturges, 340
aprendizaje dirigido, 3 Tales de Mileto, 2
argumentos, 299 Venables, 206, 258, 307
array, 169 Wickham, 269, 383
asignación, 66 Wilkinson, 269
múltiple, 66 Wilks, 17
autores ayuda, 51
Alhazen, 2
Altman, 10, 13, 14 búsqueda bibliográfica, 7
Aragón, 40 base de datos, 8, 31, 173
Aristóteles, 2 etiqueta, 183
Armitage, 169 mezclar, 180
Bacon, 11 registros, 183
Becker, 17, 82 submuestras, 179
Box, 3 becas FIS, 8
Brahe, 2 bioconductor, 18
Browner, 13 bioinformática, 19, 251
Chalmers, 4
Chambers, 17, 299, 358 cálculo vectorrizado, 318
Chang, 270 caja negra, 299
Chongsuvivatwong, 40 calculadora, 43
Cleveland, 225, 251 Cantabria, 249
Cobb, 48 catecolaminas, 170
Copérnico, 2 categorı́a de referencia, 120
Cummings, 13 CEIC, 8
Dalgaard, 18 ciencia, 1
Descartes, 2 citometrı́a, 251
Dhal, 355 clase
Du Bois, 47 Date, 190
Fayerabend, 4 POSIXct, 190
Fibonacci, 321 POSIXlt, 190
Fox, 325 clase S3, 358
Galileo, 2 clase S4, 365
Gentelman, 75 cociente, 44
Gentleman, 17 coeficiente
Grady, 13 de correlación, 10
Hintze, 257 coerción, 85
Hjalmarson, 140 coma, 63
Hulley, 13 comandos, 65
Hume, 3 concatenación, 94
Ihaka, 17 consenso, 4
Ioannidis, 10, 14 contrastes polinómicos, 121
Jones, 62 CRAN, 18
Kay, 355 criterios
Kepler, 2 de exclusión, 8
Kleinbaum, 170 de inclusión, 8
Kuhn, 4 cuerpo de conocimientos cientı́ficos, 2, 11
Lakatos, 4 currı́culum vitae, 8
Matloff, 91 curvas, 283
Mosteller, 47 curvas ROC, 42
Muenchen, 308
Newcombe, 40 dı́a
Newman, 13 sidéreo, 189
Newton, 2 solar, 189
Nygaard, 355 dataframe, 173
Owen, 306 datos ausentes, 104
Poper, 4 dendogramas, 238
Ripley, 258, 307 densidad, 222
Rotondi, 40 directorio de trabajo, 34

diseño experimental, 7 anónima, 307

dividendo, 44 argumentos, 45, 300
divisor, 44 cuerpo, 301
entorno, 302
Eclipse, 26 inmutable, 308
edad, 189 mutable, 308
ejecución repetitiva, 320 resultado, 306
elementos especiales, 103 funciones
empirismo, 11 matemáticas, 43
encapsulación, 357 vectoriales, 113
enclosure, 206 funciones primitivas, 303
ensayo clı́nico, 7
entorno, 205 garbage collector, 205
actual, 206 geoms, 270
base, 206 goniómetro, 48
de trabajo, 206 gráfico
global, 206 assoc-plot, 234
vacı́o, 206 boxplot, 224
entorno de trabajo, 313 condicional, 232
error de redondeo, 71 de barras, 220, 285
escalar, 92 de contornos, 236
escoliosis, 49 de pétalos, 230
especificidad, 330 de puntos, 225, 259
ESS, 26 de tartas, 220
estadı́stica dinámico, 246
bivariable, 10 dotchart, 225
multivariable, 10 fourfold-plot, 234
estado actual de la ciencia, 2 interaction plot, 229
estilo incorrecto, 61 mat-plot, 231
estilo interactivo, 293 mosaic-plot, 232
estructura de control, 314 Q-Q, 226
estudios scatter-plot, 226
de casos y controles, 7 smoothScatter, 235
de cohortes, 7 spine-plot, 233
epidemiológicos, 288 trellis, 251
transversales, 7 tridimensional, 237, 263
excel, 9 violinplot, 257
expresión, 66 gráficos
exprimento, 7 dot plot, 223
gramática, 65
fórmula, 199 guı́a de estilo, 61
factores, 117 GUI, 25
categorı́as, 117
no ordenados, 124 hipótesis, 7
ordenados, 121, 124 inicial, 3
falsabilidad, 2 modificada, 3
farmacocinética, 251 hipotermia
FDA, 19 clasificación de Berlı́n, 45
fechas, 189 histograma, 221, 252, 276
feedback, 18 de densidad, 253, 278
filósofos hora
anarquı́a, 4 legal, 189
de consenso, 4 local, 189
inductistas, 3 zulú, 189
refutacionistas, 4 horario
sociohistóricos, 4 de invierno, 189
FiO2 , 45 de verano, 189
frame, 206
fuerza máxima, 253 IDE, 25
función, 69 identación, 29, 63
ámbito, 307 IMC, 44
ámbito léxico, 307 indeterminaciones, 104

intervalo de confianza NCSS, 10

de Wilson, 10 nivel de referencia, 119
investigación, 1 nombres, 61
cientı́fica, 5 de ficheros, 61
investigador, 1 de funciones, 62
investigar, 5 de variables, 62
notación húngara, 62, 73
JGR, 26 Notepad++, 26
nube de puntos, 271
la máquina reactiva, 356 numero
laboratorios Bell, 213 impar, 96
lenguaje
C, 83 objetivos del estudio, 7
de programación, 18, 25 objeto, 73
FORTRAN, 83 objetos, 299
S, 213 OOP, 20
Smalltalk, 355 open source, 19
SQL, 9 operador, 68
lenguaje S, 17 de asignación, 64
ley Normal, 281 operador bolean o, 317
libro operador de asignación, 304
blue, 17 orden alfabético, 117
brown, 17
white, 17 package
lingua franca, 19 MASS, 213
lista, 92, 139 palabras
listas, 92 a evitar, 75
llaves reservadas, 74
de apertura, 63 palabras reservadas, 62
de cı́erre, 63 PaO2 , 45
paquete, 40
método, 2 asbio, 40
método cientı́fico, 1 base, 35
fases, 5 binGroup, 40
módulo, 44, 45 binom, 40
manual operativo, 8 binomSamSize, 40
mapa bitops, 35
de Cantabria, 288 boot, 35
mapas, 248, 266 car, 40
marco, 206 caTools, 35
margen class, 35
de la figura, 214 cluster, 35
externo, 214 codetools, 35
interno, 214 compiler, 35
matriz, 149 DAAG, 40
de correlaciones, 286 datasets, 35
matriz de correlaciones, 247 dBase, 35
matriz inversa, 166 Epi, 40
memoria, 73 epibasix, 40
metodologı́a de la investigación, 11 epicalc, 40, 76
metoprolol, 140 epinet, 40
microarray, 19 epiR, 40
Minitab, 10 epitools, 40
missing, 104 foreign, 35
mosaic.plot, 134 ggcorrplot, 290
multiplataforma, 19 ggplot2, 270
graphics, 35
número grDevices, 35
impar, 45 grid, 35
natural, 96 gtools, 35
par, 45 Hmisc, 40
NA, 94 KernSmooth, 35

lattice, 35, 251 redondeo, 45

latticeExtra, 266 refutación deductiva, 4
lubridate, 197 repeticiones, 97
MASS, 35 reproducibilidad, 2
Matrix, 35 resto (división), 44
methods, 35 revisión bibliográfica, 5
mgcv, 35 RGui, 26
microbenchmark, 385 riesgo relativo, 171
nlme, 35 RStudio, 26
nnet, 35 RStudio panel
nortest, 40 console, 29
parallel, 35 environment, 30
prettyR, 40 plots, 31
pROC, 40 source, 28
rpart, 35 ruido, 2
spatial, 35
splines, 35 S-PLUS, 10, 17
stats, 35 sı́ndrome GIGO, 9
stats4, 35 SAS, 10
survival, 35 scientia potentia est, 1
tcltk, 35 SciViews, 26
tools, 35 script, 293
UsingR, 40 secuencias, 95
utils, 35 segundos intercalares, 189
vcd, 40 sensibilidad, 330
paquetes, 32 sepacio de trabajo, 75
actualización, 38 series de números, 95
básicos, 35 simula-67, 355
cabecera, 38 sintaxis, 65
contenido, 38, 39 sistema de ecuaciones, 167
datasets, 39 sistema internacional de medidas, 189
instalación, 37 slots, 365
recomendados, 35, 40 SPSS, 10, 19
paréntesis, 63 Stata, 10
paréntesis emparejados, 29 Statgraphics, 10
polimorfismo, 357 suavizado no pramétrico, 274
precedencia, 68 submatriz, 155
pregunta de investigación, 5 sudoku, 18
ética, 6 superficie corporal, 47
factible, 6
interesante, 6 técnica de escritura, 61
novedosa, 6 tabla
relevante, 6 de contingencia, 133
principios éticos de frecuencias, 132
autonomı́a, 6 tablas, 131
beneficencia, 6 de contingencia, 131
justicia, 6 tamaño muestral, 46
no maleficencia, 6 test
programación Kolmogorov-Smirnov, 53
orientada a objetos, 355 tiempos, 189
programador, 355 TinnR, 26
prompt, 65 transportador de ángulos, 48
proteómica, 19
proyecto de investigación, 8 variables, 8
prueba de globales, 88
r de Pearson, 10 locales, 88
Shapiro-Wilk, 9 varianza, 69
Student, 10 vector, 91, 92
publicación, 11 atómico, 140
recursivo, 140
R, 10, 17 vectores, 92
R Development Core Team, 18 atómicos, 92

caracteres, 92
complejos, 92
crudos, 92
enteros, 92
lógicos, 92
numéricos, 92
atributos, 92
complejos, 100
de caracteres, 101
lógicos, 98
longitud, 92
nombrar, 105
numéricos, 98
reales, 99
tipo, 92
velocidad de ejecución, 383
verdad, 1, 2
viñetas, 55
visibilidad de las variables, 88
workspace, 75
zona horaria, 189, 191

Enero, 2017

L
a investigación, que es uno de los principales motores
del desarrollo de un país, solo tiene éxito cuando se hace
adecuadamente, es decir, cuando prosigue los pasos del
Método Científico, ya que si sigue un camino confundido no
llegará a alcanzar el fin deseado. Por tanto, se necesita formación
en metodología de investigación. Además, precisa de unas
herramientas adecuadas, siendo una de ellas un programa que
permita el análisis estadístico de los datos: el programa R.
El investigador debe tener soltura en el manejo de la informática,
para lo cual es fundamental conocer el programa R, que destaca
por sus excelentes capacidades estadísticas y gráficas.
Sin lugar a dudas R es el mejor y más completo programa
estadístico. Además de ser totalmente gratuito, sobrepasa en
capacidades a cualquier otro programa, comercial o no, por lo
que es deseable que todo investigador se vaya introduciendo
en el manejo de este programa. Su conocimiento permitirá al
investigador realizar cualquier técnica estadística que necesite
para analizar los datos de su estudio. Es un programa con una
curva de aprendizaje lenta al principio debido a que es muy
exigente en la escritura correcta de su lenguaje. Una vez superada
esta fase inicial, el aprendizaje es más fácil y seguro.
Se ha dividido el libro en cuatro partes fundamentales:
Una primera parte, dedicada al programa R y su entorno. Es
primordial que el investigador tenga correctamente instalado
el programa R y las librerías (paquetes) de apoyo. El manejo
adecuado de todo ello, así como de las ayudas y gestión de los
ficheros y gráficos se facilita enormemente con el entorno de
programación RStudio.
Una segunda parte, se dedica a conocer la sintaxis y la gramática
de R. Si alguien quiere manejar un lenguaje, previamente debe
aprenderlo correctamente. Este esfuerzo se ve facilitado con
multitud de ejemplos y problemas que le proporcionarán la soltura
necesaria para manejar los diferentes objetos de R.
La tercera parte se dedica a estudiar sus excelentes capacidades
gráficas. El investigador que quiera transmitir sus ideas y hallazgos
debe antes aprender a crear los gráficos adecuados. Se presentan
los tres sistemas disponibles actualmente: grid, lattice y ggplot2.
En ellos el investigador descubrirá un sinfín de posibilidades.
La cuarta parte del libro se dedica a la programación en R. Se
presenta paulatinamente para que el lector no se agobie, ni se
www.editorialuc.es
asuste. Aprenderá a programar numerosas funciones según sus

necesidades.
20 €
IBIC: YQ, MBNS, PBT, 4GE

ISBN 978-84-8102-808-9

El Programa R, Herramienta Clave en Investigación - Carlos Redondo Figuero PDF

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

El Programa R, Herramienta Clave en Investigación - Carlos Redondo Figuero PDF

Uploaded by

Copyright:

Available Formats

El programa R,

Dña. Sonia Castanedo Bárcena

Carlos G. Redondo Figuero

1. R (Programa de ordenador). 2. Estadística – Informática.

ibiC: YQtU, Pbt, Mbns, 4GE

Esta edición es propiedad de la Editorial dE la UnivErsidad dE Cantabria, cualquier forma

© Carlos Godofredo redondo Figuero

isbn: 978-84-8102-808-9 (PdF)

3. El entorno de programación RStudio 25

Libros de Estadística en PDF | Statistics Books in PDF

3.3.1. Ventana ((Source)) . . . . . . . . . . . . . . . . . . . . . . . 28

Libros de Estadística en PDF | Statistics Books in PDF

8. Sintaxis del lenguaje R 67

Libros de Estadística en PDF | Statistics Books in PDF

10.4.3. En vectores de caracteres . . . . . . . . . . . . . . . . . . 107

11. Factores 119

12. Tablas 133

13. Listas 141

Libros de Estadística en PDF | Statistics Books in PDF

14. Matrices 151

15. Arrays 171

16. Data frames 175

Libros de Estadística en PDF | Statistics Books in PDF

17. Tiempo en R 191

18. Fórmulas en R 201

19. Entornos en R 207

III GRÁFICOS EN R 213

Libros de Estadística en PDF | Statistics Books in PDF

20.2.3. Sı́mbolos . . . . . . . . . . . . . . . . . . . . . . . . . . . . 219

21. Gráficos Trellis 253

22. Gráficos ggplot2 271

Libros de Estadística en PDF | Statistics Books in PDF

24. Programación de funciones 301

25. Estructuras de control 315

26. Primeras funciones escritas por el usuario 327

27. Funciones de utilidad 337

Libros de Estadística en PDF | Statistics Books in PDF

27.1.5. Pruebas diagnósticas: Fprueba diag() . . . . . . . . . 347

29. Programación orientada a objetos 359

30. La función apply y similares 371

31. Programación eficiente 387

Libros de Estadística en PDF | Statistics Books in PDF

Libros de Estadística en PDF | Statistics Books in PDF

Toda investigación implica la recogida de datos, almacenamiento, depura-

Prof. Benedicto Crespo Facorro

Libros de Estadística en PDF | Statistics Books in PDF

Libros de Estadística en PDF | Statistics Books in PDF

conocer el programa R, que destaca por sus excelentes capacidades estadı́sti-

Santander, 5 de noviembre de 2016

Libros de Estadística en PDF | Statistics Books in PDF

El hombre siempre ha querido dar una explicación a la realidad que le ro-

1.2. El Método Cientı́fico

Actualmente se considera al método cientı́fico como el camino o estrate-

1.2.1. Hacer ciencia

Libros de Estadística en PDF | Statistics Books in PDF

1.3. Fundamentos filosóficos

1.3.1. Los inductistas

Libros de Estadística en PDF | Statistics Books in PDF

Figura 1.3: En la izquierda: David Hume (1711–1776), máximo representante de los

1.3.2. Los refutacionistas

1.4. Fases del Método Cientı́fico

Libros de Estadística en PDF | Statistics Books in PDF

1.4.1. Pregunta de investigación