Una Introducción A R

Una introducción a R
Notas sobre R: Un entorno de programación para análisis de datos y gráficos

Versión 3.2.3 (20151210)
WN Venables, DM Smith y el
equipo central de R
Este manual es para R, versión 3.2.3 (20151210).
Copyright c 1990 WN Venables
Copyright c 1992 WN Venables & DM Smith Copyright c
1997 R. Gentleman & R. Ihaka Copyright c 1997,
1998 M. Maechler Copyright c 1999–2015
R Core Team
Se concede permiso para realizar y distribuir copias literales de este manual siempre que el
aviso de derechos de autor y este aviso de permiso se conserven en todas las copias.
Se concede permiso para copiar y distribuir versiones modificadas de este manual bajo las
condiciones de copia palabra por palabra, siempre que todo el trabajo derivado resultante se
distribuya bajo los términos de un aviso de permiso idéntico a este.
Se concede permiso para copiar y distribuir traducciones de este manual a otro idioma, bajo
las condiciones anteriores para versiones modificadas, excepto que este aviso de permiso
pueda indicarse en una traducción aprobada por el equipo central de R.
i
Tabla de contenido
Prefacio. . ...........................................................1
1 Introducción y preliminares . . . ............................2

1.1 El entorno R. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.2 Software y documentación relacionados. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.3 R y estadísticas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.4 R y el sistema de ventanas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.5 Uso interactivo de R. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.6 Una sesión introductoria. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
1.7 Obtener ayuda con funciones y características. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
Comandos 1.8 R, distinción entre mayúsculas y minúsculas, etc. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
1.9 Recuperación y corrección de comandos anteriores. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.10 Ejecutar comandos o desviar la salida a un archivo. . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.11 Permanencia de datos y eliminación de objetos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
2 manipulaciones simples; números y vectores. . . ..............7

2.1 Vectores y asignación. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
2.2 Aritmética vectorial. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
2.3 Generando secuencias regulares. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
2.4 Vectores lógicos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
2.5 Valores faltantes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
2.6 Vectores de caracteres. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
2.7 vectores índice; Seleccionar y modificar subconjuntos de un conjunto de datos. . . . . . . . . . . . . . . . . . . . . . . 10
2.8 Otros tipos de objetos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
3 Objetos, sus modos y atributos. . . . . . . . . . . . . . . . . . . . . . . . 13

3.1 Atributos intrínsecos: modo y longitud. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
3.2 Cambiar la longitud de un objeto. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
3.3 Obtención y configuración de atributos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
3.4 La clase de un objeto. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
4 Factores ordenados y desordenados. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . dieciséis

4.1 Un ejemplo específico. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . dieciséis
4.2 La función tapply() y matrices irregulares. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . dieciséis
4.3 Factores ordenados. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
5 Arreglos y matrices. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
5.1 Matrices. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
5.2 Indexación de matrices. Subsecciones de una matriz. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
5.3 Matrices de índice. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
5.4 La función matriz(). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
5.4.1 Aritmética mixta vectorial y matricial. La regla del reciclaje. . . . . . . . . . . . . . . . . . . . . . . . 20
5.5 El producto exterior de dos matrices. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
5.6 Transposición generalizada de una matriz. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
5.7 Instalaciones de la matriz. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
5.7.1 Multiplicación de matrices. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
ii
5.7.2 Ecuaciones lineales e inversión. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22

5.7.3 Valores propios y vectores propios. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
5.7.4 Descomposición de valores singulares y determinantes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
5.7.5 Ajuste de mínimos cuadrados y descomposición QR. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
5.8 Formación de matrices particionadas, cbind() y rbind(). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
5.9 La función de concatenación, c(), con matrices. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
5.10 Tablas de frecuencia a partir de factores. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
6 Listas y marcos de datos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26

6.1 Listas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
6.2 Construcción y modificación de listas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
6.2.1 Concatenar listas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
6.3 Marcos de datos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
6.3.1 Creación de marcos de datos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
6.3.2 adjuntar() y separar(). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
6.3.3 Trabajar con marcos de datos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
6.3.4 Adjuntar listas arbitrarias. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
6.3.5 Gestión de la ruta de búsqueda. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
7 Lectura de datos de archivos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30

7.1 La función read.table(). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
7.2 La función scan(). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
7.3 Acceso a conjuntos de datos integrados. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
7.3.1 Carga de datos de otros paquetes de R. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
7.4 Edición de datos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
8 Distribuciones de probabilidad. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
8.1 R como un conjunto de tablas estadísticas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
8.2 Examinar la distribución de un conjunto de datos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
8.3 Pruebas de una y dos muestras. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
9 Agrupación, bucles y ejecución condicional. . . . . . . . . . . . . . . . . 40

9.1 Expresiones agrupadas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
9.2 Declaraciones de control. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
9.2.1 Ejecución condicional: sentencias if. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
9.2.2 Ejecución repetitiva: bucles for, repetir y mientras. . . . . . . . . . . . . . . . . . . . . . . . . . 40
10 Escribir tus propias funciones. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42

10.1 Ejemplos sencillos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
10.2 Definición de nuevos operadores binarios. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
10.3 Argumentos con nombre y valores predeterminados. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
10.4 El argumento '...'. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
10.5 Asignaciones dentro de funciones. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
10.6 Ejemplos más avanzados. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
10.6.1 Factores de eficiencia en diseños de bloques. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
10.6.2 Eliminar todos los nombres en una matriz impresa. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
10.6.3 Integración numérica recursiva. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
10.7 Alcance. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
10.8 Personalización del entorno. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
10.9 Clases, funciones genéricas y orientación a objetos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
III
11 Modelos estadísticos en R. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
11.1 Definición de modelos estadísticos; fórmulas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
11.1.1 Contrastes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
11.2 Modelos lineales. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
11.3 Funciones genéricas para extraer información del modelo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
11.4 Análisis de varianza y comparación de modelos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
11.4.1 Tablas ANOVA. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
11.5 Actualización de modelos instalados. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
11.6 Modelos lineales generalizados. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
11.6.1 Familias. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
11.6.2 La función glm(). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
11.7 Modelos de mínimos cuadrados y máxima verosimilitud no lineales. . . . . . . . . . . . . . . . . . . . . . . . . 59
11.7.1 Mínimos cuadrados. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
11.7.2 Máxima probabilidad. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
11.8 Algunos modelos no estándar. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
12 Procedimientos gráficos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
12.1 Comandos de trazado de alto nivel. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
12.1.1 La función trama(). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
12.1.2 Visualización de datos multivariados. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64
12.1.3 Mostrar gráficos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64
12.1.4 Argumentos para funciones de trazado de alto nivel. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . sesenta y cinco
12.2 Comandos de trazado de bajo nivel. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
12.2.1 Anotación matemática. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67
12.2.2 Fuentes vectoriales Hershey. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67
12.3 Interactuar con gráficos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67
12.4 Uso de parámetros gráficos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68
12.4.1 Cambios permanentes: la función par(). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68
12.4.2 Cambios temporales: Argumentos a funciones gráficas. . . . . . . . . . . . . . . . . . . . . . . 69
12.5 Lista de parámetros gráficos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
12.5.1 Elementos gráficos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70
12.5.2 Ejes y marcas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
12.5.3 Márgenes de la figura. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
12.5.4 Entorno de figuras múltiples. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73
12.6 Controladores de dispositivos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74
12.6.1 Diagramas PostScript para documentos tipográficos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74
12.6.2 Múltiples dispositivos gráficos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
12.7 Gráficos dinámicos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76
13 paquetes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77
13.1 Paquetes estándar. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77
13.2 Paquetes aportados y CRAN . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77
13.3 Espacios de nombres. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78
14 instalaciones del sistema operativo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79

14.1 Archivos y directorios. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79
14.2 Rutas de archivos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79
14.3 Comandos del sistema. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80
14.4 Compresión y Archivos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80
Apéndice AA sesión de muestra. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82

IV
Apéndice B Invocando R . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85
B.1 Invocar R desde la línea de comando. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85
B.2 Invocar R en Windows. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89
B.3 Invocar R en OS X. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90
B.4 Scripting con R. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90
Apéndice C El editor de línea de comandos. . . . . . . . . . . . . . . . . . . . . . . 92

C.1 Preliminares. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92
C.2 Acciones de edición. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92
C.3 Resumen del editor de línea de comandos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92
Apéndice D Función e índice de variable. . . . . . . . . . . . . . . . . . . . 94
Apéndice E Índice de conceptos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97
Apéndice F Referencias. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99
Prefacio 1
Prefacio
Esta introducción a R se deriva de un conjunto original de notas que describen los entornos S y SPlus, escritas en
1990–2 por Bill Venables y David M. Smith cuando estaban en la Universidad de Adelaide. Hemos realizado una serie
de pequeños cambios para reflejar las diferencias entre los programas R y S, y ampliamos parte del material.
Nos gustaría agradecer cordialmente a Bill Venables (y David Smith) por otorgarnos permiso para distribuir esta
versión modificada de las notas de esta manera y por apoyar a R desde hace mucho tiempo.
Comentarios y correcciones siempre son bienvenidos. Por favor dirija su correspondencia por correo electrónico a
Rcore@Rproject.org.
Sugerencias para el lector La mayoría de

los principiantes en R comenzarán con la sesión introductoria del Apéndice A. Esto debería brindarles cierta
familiaridad con el estilo de las sesiones de R y, lo que es más importante, cierta retroalimentación instantánea sobre
lo que realmente sucede.
Muchos usuarios recurrirán a R principalmente por sus funciones gráficas. Consulte el Capítulo 12 [Gráficos],
página 63, que se puede leer casi en cualquier momento y no es necesario esperar hasta que se hayan digerido
todas las secciones anteriores.
Capítulo 1: Introducción y preliminares 2
1 Introducción y preliminares
1.1 El entorno R
R es un conjunto integrado de funciones de software para manipulación de datos, cálculo y visualización gráfica. Entre otras cosas,
tiene: • una eficaz instalación de almacenamiento
y manejo de datos, • un conjunto de operadores para cálculos en
matrices, en particular matrices, • una colección grande, coherente e integrada de herramientas
intermedias para el análisis de datos, • instalaciones gráficas para el análisis de datos y mostrar directamente
en la computadora o en el disco duro

copiar, y
• un lenguaje de programación bien desarrollado, simple y eficaz (llamado 'S') que incluye condicionales, bucles, funciones
recursivas definidas por el usuario y funciones de entrada y salida. (De hecho, la mayoría de las funciones proporcionadas
por el sistema están escritas en lenguaje S).
El término "entorno" pretende caracterizarlo como un sistema totalmente planificado y coherente, en lugar de una acumulación
incremental de herramientas muy específicas e inflexibles, como suele ser el caso con otros programas de análisis de datos.
R es en gran medida un vehículo para métodos de análisis de datos interactivos en desarrollo recientemente. Se ha
desarrollado rápidamente y se ha ampliado con una gran colección de paquetes. Sin embargo, la mayoría de los programas
escritos en R son esencialmente efímeros, escritos para un solo análisis de datos.
1.2 Software y documentación relacionados

R puede considerarse como una implementación del lenguaje S, desarrollado en los laboratorios Bell por Rick Becker, John
Chambers y Allan Wilks, y que también constituye la base de los sistemas SPlus.
La evolución del lenguaje S se caracteriza por cuatro libros de John Chambers y coautores. Para R, la referencia básica es
The New S Language: A Programming Environment for Data Analysis and Graphics de Richard A. Becker, John M. Chambers y
Allan R. Wilks.
Las nuevas características de la versión de 1991 de S se tratan en Modelos estadísticos en S editado por John M. Chambers y
Trevor J. Hastie. Los métodos formales y las clases del paquete de métodos se basan en los descritos en Programación con datos
de John M. Chambers. Consulte el Apéndice F [Referencias], página 99, para referencias precisas.
Actualmente existen varios libros que describen cómo utilizar R para análisis de datos y estadísticas, y la documentación para
S/SPlus normalmente se puede utilizar con R, teniendo en cuenta las diferencias entre las implementaciones de S. Consulte la
sección "¿Qué documentación existe para R?" en las preguntas frecuentes del sistema estadístico R.
1.3 R y estadísticas
Nuestra introducción al entorno R no mencionó las estadísticas, sin embargo, mucha gente usa R como sistema estadístico.
Preferimos pensar en un entorno en el que se han implementado muchas técnicas estadísticas clásicas y modernas. Algunos de
ellos están integrados en el entorno base de R, pero muchos se suministran como paquetes. Hay alrededor de 25 paquetes
suministrados con R (llamados paquetes “estándar” y “recomendados”) y muchos más están disponibles a través de la familia de
sitios de Internet CRAN (a través de https://CRAN.Rproject.org) y otros lugares. Más adelante se proporcionarán más detalles
sobre los paquetes (consulte el Capítulo 13 [Paquetes], página 77).
La mayoría de las estadísticas clásicas y gran parte de la metodología más reciente están disponibles para su uso con R, pero
Es posible que los usuarios deban estar preparados para trabajar un poco para encontrarlo.
Existe una diferencia importante en filosofía entre S (y por tanto R) y los otros sistemas estadísticos principales.
En S, un análisis estadístico normalmente se realiza en una serie de pasos, y los resultados intermedios se almacenan
en objetos. Por lo tanto, mientras que SAS y SPSS darán abundantes resultados de un análisis de regresión o
discriminante, R dará un resultado mínimo y almacenará los resultados en un objeto adecuado para su posterior
interrogación por otras funciones de R.
1.4 R y el sistema de ventanas.

La forma más conveniente de utilizar R es en una estación de trabajo de gráficos que ejecute un sistema de ventanas.
Esta guía está dirigida a usuarios que cuentan con esta facilidad. En particular, ocasionalmente nos referiremos al uso
de R en un sistema X Window, aunque la mayor parte de lo que se dice se aplica generalmente a cualquier
implementación del entorno R.
La mayoría de los usuarios encontrarán necesario interactuar directamente con el sistema operativo de su
computadora de vez en cuando. En esta guía, analizamos principalmente la interacción con el sistema operativo en
máquinas UNIX. Si está ejecutando R en Windows u OS X, deberá realizar algunos pequeños ajustes.
Configurar una estación de trabajo para aprovechar al máximo las características personalizables de R es un
procedimiento sencillo aunque algo tedioso, y no se considerará más aquí. Los usuarios que tengan dificultades
deben buscar ayuda de expertos locales.
1.5 Usando R interactivamente

Cuando utiliza el programa R, emite un mensaje cuando espera comandos de entrada. El mensaje predeterminado es
'>', que en UNIX puede ser el mismo que el mensaje del shell, por lo que puede parecer que no sucede nada. Sin
embargo, como veremos, es fácil cambiar a un indicador R diferente si lo desea. Supondremos que el símbolo del
shell de UNIX es '$'.
Al usar R bajo UNIX, el procedimiento sugerido para la primera ocasión es el siguiente: 1. Cree un
subdirectorio separado, digamos trabajo, para contener archivos de datos en los que usará R para este problema.
Este será el directorio de trabajo siempre que utilice R para este problema en particular. $ trabajo mkdir $ trabajo
cd
2. Inicie el programa R con el comando $R
3. En este punto se pueden emitir comandos R (ver más adelante).

4. Para salir del programa R, el comando es > q()
En este punto se le preguntará si desea guardar los datos de su sesión de R. En algunos sistemas, esto abrirá
un cuadro de diálogo y en otros recibirá un mensaje de texto al que puede responder sí, no o cancelar (una
abreviatura de una sola letra será suficiente) para guardar los datos antes de salir, salir sin guardar o volver a la
sesión R. Los datos que se guarden estarán disponibles en futuras sesiones de R.
Otras sesiones de R son sencillas.

1. Haga funcionar el directorio de trabajo e inicie el programa como antes: $ cd work $
R
2. Utilice el programa R y finalice con el comando q() al final de la sesión.

Para utilizar R en Windows el procedimiento a seguir es básicamente el mismo. Cree una carpeta como directorio
de trabajo y configúrela en el campo Iniciar en en su acceso directo de R. Luego inicie R haciendo doble clic en el
icono.
1.6 Una sesión introductoria

Se recomienda encarecidamente a los lectores que deseen familiarizarse con R en una computadora antes de continuar que
trabajen en la sesión introductoria que se proporciona en el Apéndice A [Una sesión de muestra], página 82.
1.7 Obtener ayuda con funciones y características

R tiene una función de ayuda incorporada similar a la función man de UNIX. Para obtener más información sobre cualquier
función con nombre específico, por ejemplo resolver, el comando es
> ayuda (resolver)

Una alternativa es
> ?resolver
Para una característica especificada por caracteres especiales, el argumento debe estar entre comillas dobles o simples,
convirtiéndolo en una “cadena de caracteres”: esto también es necesario para algunas palabras con significado sintáctico,
incluidas if, for y function. > ayuda("[[")
Cualquiera de las comillas se puede utilizar para escapar de la otra, como en la cadena "Es importante". Nuestra convención
es utilizar comillas dobles para preferencia.
En la mayoría de las instalaciones de R, la ayuda está disponible en formato HTML ejecutando
> help.start() que

iniciará un navegador web que permite navegar por las páginas de ayuda con hipervínculos. En UNIX, las solicitudes de ayuda
posteriores se envían al sistema de ayuda basado en HTML. El enlace 'Motor de búsqueda y palabras clave' en la página cargada
por help.start() es particularmente útil ya que contiene una lista de conceptos de alto nivel que busca funciones disponibles.
Puede ser una excelente manera de orientarse rápidamente y comprender la amplitud de lo que R tiene para ofrecer.
El comando help.search (alternativamente ??) permite buscar ayuda de varias maneras. Por ejemplo,
> ??resolver
Pruebe ?help.search para obtener detalles y más ejemplos.

Los ejemplos sobre un tema de ayuda normalmente pueden ejecutarse mediante
> ejemplo(tema)
Las versiones de Windows de R tienen otros sistemas de ayuda opcionales: use
> ?ayuda
para mas detalles.
Comandos 1.8 R, distinción entre mayúsculas y minúsculas, etc.
Técnicamente R es un lenguaje de expresión con una sintaxis muy simple. Distingue entre mayúsculas y minúsculas, como lo
son la mayoría de los paquetes basados en UNIX, por lo que A y a son símbolos diferentes y se referirían a variables diferentes.
El conjunto de símbolos que se pueden utilizar en los nombres de R depende del sistema operativo y del país en el que se ejecuta
R (técnicamente de la configuración regional en uso). Normalmente se permiten todos los símbolos alfanuméricos1 (y en algunos
países esto incluye letras acentuadas) más '.' y '_', con la restricción de que un nombre debe comenzar con '.' o una letra, y si
comienza con '.' el segundo carácter no debe ser un dígito. Los nombres tienen efectivamente una longitud ilimitada.
Los comandos elementales constan de expresiones o asignaciones. Si una expresión se proporciona como comando, se
evalúa, se imprime (a menos que se haga invisible específicamente) y el valor se pierde.
Una asignación también evalúa una expresión y pasa el valor a una variable, pero el resultado no se imprime automáticamente.
1
Para el código R portátil (incluido el que se utilizará en paquetes R) solo se debe utilizar A–Za–z0–9.
Machine Translated by Google
Los comandos están separados por un punto y coma (';') o por una nueva línea. Los comandos elementales se pueden
agrupar en una expresión compuesta mediante llaves ('{' y '}'). Los comentarios se pueden colocar casi2 en cualquier lugar,
comenzando con una marca hash ('#'), todo hasta el final de la línea es un
comentario.
Si un comando no está completo al final de una línea, R dará un mensaje diferente, de forma predeterminada
+
en la segunda línea y en las siguientes y continúe leyendo la entrada hasta que el comando se complete sintácticamente.
Este mensaje puede ser modificado por el usuario. Generalmente omitiremos el mensaje de continuación e indicaremos la
continuación mediante una simple sangría.
Las líneas de comando ingresadas en la consola están limitadas3 a aproximadamente 4095 bytes (no caracteres).
1.9 Recuperación y corrección de comandos anteriores

En muchas versiones de UNIX y Windows, R proporciona un mecanismo para recuperar y volver a ejecutar comandos
anteriores. Las teclas de flecha verticales del teclado se pueden utilizar para desplazarse hacia adelante y hacia atrás a
través del historial de comandos. Una vez que un comando se ubica de esta manera, el cursor se puede mover dentro del
comando usando las teclas de flecha horizontales y los caracteres se pueden eliminar con la tecla SUPR o agregar con
las otras teclas. Más detalles se proporcionan más adelante: consulte el Apéndice C [El editor de línea de comandos],
página 92.
Las capacidades de recuperación y edición en UNIX son altamente personalizables. Puedes averiguarlo
cómo hacer esto leyendo la entrada del manual de la biblioteca readline.
Alternativamente, el editor de texto de Emacs proporciona mecanismos de soporte más generales (a través de ESS,
Emacs Speaks Statistics) para trabajar interactivamente con R. Consulte la sección “R y Emacs” en las preguntas
frecuentes del sistema estadístico R.
1.10 Ejecutar comandos desde un archivo o desviar la salida a un archivo Si los comandos4 están almacenados
en un archivo externo, digamos comandos.R en el directorio de trabajo trabajo, se pueden ejecutar en cualquier momento
en una sesión de R con el comando > fuente("comandos.R ")
Para Windows Source también está disponible en el menú Archivo. La función fregadero,
> fregadero("record.lis")
desviará toda la salida posterior de la consola a un archivo externo, record.lis. El comando

> fregadero()
lo restaura a la consola una vez más.
1.11 Permanencia de datos y eliminación de objetos

Las entidades que R crea y manipula se conocen como objetos. Pueden ser variables, matrices de números, cadenas de
caracteres, funciones o estructuras más generales construidas a partir de dichos componentes.
Durante una sesión de R, los objetos se crean y almacenan por nombre (discutimos este proceso en el
próxima sesión). El comando R >
objetos()
(alternativamente, ls()) se puede usar para mostrar los nombres de (la mayoría de) los objetos que están actualmente
almacenados en R. La colección de objetos actualmente almacenados se llama espacio de trabajo.
Para eliminar objetos está disponible la función rm:
2
no dentro de cadenas, ni dentro de la lista de argumentos de una definición
3
de función, algunas de las consolas no le permitirán ingresar más, y entre las que lo harán, algunas descartarán
silenciosamente el exceso y otras lo usarán como inicio de la siguiente línea.
4
de longitud ilimitada.
> rm(x, y, z, tinta, basura, temperatura, foo, barra)

Todos los objetos creados durante una sesión de R se pueden almacenar permanentemente en un archivo
para su uso en futuras sesiones de R. Al final de cada sesión de R, se le brinda la oportunidad de guardar
todos los objetos disponibles actualmente. Si indica que desea hacer esto, los objetos se escriben en un
archivo llamado .RData5 en el directorio actual y las líneas de comando utilizadas en la sesión se guardan en
un archivo llamado .Rhistory.
Cuando R se inicia más tarde desde el mismo directorio, recarga el espacio de trabajo desde este
archivo. Al mismo tiempo se recarga el historial de comandos asociados.
Se recomienda utilizar directorios de trabajo separados para los análisis realizados con R. Es bastante
común que se creen objetos con nombres xey durante un análisis.
Nombres como este suelen tener significado en el contexto de un único análisis, pero puede resultar bastante
difícil decidir cuáles podrían ser cuando se han realizado varios análisis en el mismo directorio.
5
El "punto" inicial en este nombre de archivo lo hace invisible en las listas de archivos normales en UNIX y en las listas de archivos GUI
predeterminadas en OS X y Windows.
Capítulo 2: Manipulaciones simples; numeros y vectores 7
2 manipulaciones simples; numeros y vectores
2.1 Vectores y asignación

R opera en estructuras de datos con nombre. La estructura más simple de este tipo es el vector numérico, que es
una entidad única que consta de una colección ordenada de números. Para configurar un vector llamado x, digamos,
que consta de cinco números, a saber, 10,4, 5,6, 3,1, 6,4 y 21,7, utilice el comando R
> x < c(10,4, 5,6, 3,1, 6,4, 21,7)
Esta es una declaración de asignación que utiliza la función c() que en este contexto puede tomar un número
arbitrario de argumentos vectoriales y cuyo valor es un vector obtenido al concatenar sus argumentos de un extremo
a otro.1 Un número que
aparece solo en una expresión se toma como un vector de longitud uno.
Observe que el operador de asignación ('<'), que consta de los dos caracteres '<' ("menor que") y '' ("menos"),
aparecen estrictamente uno al lado del otro y "apunta" al objeto que recibe el valor de la expresión. En la mayoría de
los contextos, el operador '=" se puede utilizar como alternativa.
La asignación también se puede realizar utilizando la función asignar(). Una forma equivalente de hacer
la misma asignación que arriba es con: >
asignar("x", c(10.4, 5.6, 3.1, 6.4, 21.7))
El operador habitual, <, puede considerarse como un atajo sintáctico para esto.
Las asignaciones también se pueden realizar en la otra dirección, utilizando el cambio obvio en la asignación.
operador de mento. Entonces se podría hacer la misma asignación usando
> c(10,4, 5,6, 3,1, 6,4, 21,7) > x
2 . Entonces ahora si nosotros
Si una expresión se usa como un comando completo, el valor se imprime y se pierde.
fueran a utilizar el comando
> 1/x
los recíprocos de los cinco valores se imprimirían en la terminal (y el valor de x, por supuesto, no cambiaría).
La asignación adicional > y

< c(x, 0, x)
crearía un vector y con 11 entradas que consta de dos copias de x con un cero en el medio.
2.2 Aritmética vectorial

Los vectores se pueden utilizar en expresiones aritméticas, en cuyo caso las operaciones se realizan elemento por
elemento. No es necesario que todos los vectores que aparecen en la misma expresión tengan la misma longitud. Si
no es así, el valor de la expresión es un vector con la misma longitud que el vector más largo que aparece en la
expresión. Los vectores más cortos en la expresión se reciclan tantas veces como sea necesario (quizás
fraccionalmente) hasta que coincidan con la longitud del vector más largo. En particular, una constante simplemente
se repite. Entonces con las asignaciones anteriores el comando
> v < 2*x + y + 1
genera un nuevo vector v de longitud 11 construido sumando, elemento por elemento, 2*x repetido 2,2 veces, y
repetido solo una vez y 1 repetido 11 veces.
1
Con otros tipos de argumentos que no sean vectoriales, como los argumentos en modo lista, la acción de c() es bastante diferente.
Consulte la Sección 6.2.1 [Concatenación de listas], página 27.
2
En realidad, todavía está disponible como .Last.value antes de que se ejecute cualquier otra declaración.
Los operadores aritméticos elementales son los habituales +, , *, / y ^ para elevar a una potencia. Además,
están disponibles todas las funciones aritméticas comunes. log, exp, sin, cos, tan, sqrt, etc., todos tienen su
significado habitual. max y min seleccionan los elementos más grandes y más pequeños de un vector
respectivamente. rango es una función cuyo valor es un vector de longitud dos, es decir, c(min(x), max(x)).
length(x) es el número de elementos en x, sum(x) da el total de los elementos en x y prod(x) su producto.
Dos funciones estadísticas son la media (x), que calcula la media de la muestra, que es la misma
como suma(x)/longitud(x), y var(x) que da
suma((xmedia(x))^2)/(longitud(x)1)
o varianza muestral. Si el argumento de var() es una matriz nporp, el valor es una matriz de covarianza de
muestra pporp obtenida considerando las filas como vectores de muestra de variables p independientes.
sort(x) devuelve un vector del mismo tamaño que x con los elementos ordenados en orden creciente; sin
embargo, hay otras funciones de clasificación más flexibles disponibles (consulte order() o sort.list() que
producen una permutación para realizar la clasificación).
Tenga en cuenta que max y min seleccionan los valores más grandes y más pequeños en sus argumentos,
incluso si se les dan varios vectores. Las funciones máxima y mínima paralelas pmax y pmin devuelven un vector
(de longitud igual a su argumento más largo) que contiene en cada elemento el elemento más grande (más
pequeño) en esa posición en cualquiera de los vectores de entrada.
Para la mayoría de los propósitos, al usuario no le preocupará si los "números" en un vector numérico son
enteros, reales o incluso complejos. Los cálculos internos se realizan como números reales de doble precisión o
números complejos de doble precisión si los datos de entrada son complejos.
Para trabajar con números complejos, proporcione una parte compleja explícita. De este modo
sqrt(17)
dará NaN y una advertencia, pero
sqrt(17+0i)
hará los cálculos como números complejos.
2.3 Generando secuencias regulares

R tiene varias funciones para generar secuencias de números de uso común. Por ejemplo 1:30 es el vector c(1,
2, ..., 29, 30). El operador de dos puntos tiene alta prioridad dentro de una expresión, por lo que, por ejemplo,
2*1:15 es el vector c(2, 4, ..., 28, 30). Ponga n < 10 y compare las secuencias 1:n1 y 1:(n1).
La construcción 30:1 se puede utilizar para generar una secuencia al revés.

La función seq() es una función más general para generar secuencias. Tiene cinco argumentos, de los cuales
sólo algunos pueden especificarse en cualquier llamada. Los dos primeros argumentos, si se dan, especifican el
principio y el final de la secuencia, y si estos son los dos únicos argumentos dados, el resultado es el mismo que
el operador de dos puntos. Es decir, seq(2,10) es el mismo vector que 2:10.
Los argumentos para seq() y para muchas otras funciones de R también se pueden dar en forma nombrada,
en cuyo caso el orden en el que aparecen es irrelevante. Los dos primeros argumentos pueden denominarse
desde=valor y hasta=valor; por lo tanto, seq(1,30), seq(from=1, to=30) y seq(to=30, from=1) son todos iguales a
1:30. Los siguientes dos argumentos de seq() pueden denominarse by=value y length=value, que especifican un
tamaño de paso y una longitud para la secuencia respectivamente. Si no se da ninguno de estos, se supone que
el valor predeterminado es =1.
Por ejemplo >
seq(5, 5, by=.2) > s3 genera en
s3 el vector c(5.0, 4.8, 4.6, ..., 4.6, 4.8, 5.0). Similarmente
> s4 < seq(longitud=51, desde=5, por=.2)

genera el mismo vector en s4.
El quinto argumento puede denominarse together=vector, que normalmente se utiliza como único argumento
para crear la secuencia 1, 2, ..., longitud(vector), o la secuencia vacía si el vector está vacío (como puede ser ).
Una función relacionada es rep() que se puede utilizar para replicar un objeto de varias formas complicadas.
La forma más simple es > s5 <
rep(x, veces=5)
que colocará cinco copias de x de un extremo a otro en s5. Otra versión útil es > s6 <
rep(x, each=5)
que repite cada elemento de x cinco veces antes de pasar al siguiente.
2.4 Vectores lógicos Además de
los vectores numéricos, R permite la manipulación de cantidades lógicas. Los elementos de un vector lógico
pueden tener los valores VERDADERO, FALSO y NA (para "no disponible", ver más abajo). Los dos primeros
suelen abreviarse como T y F, respectivamente. Sin embargo, tenga en cuenta que T y F son solo variables que
están configuradas en VERDADERO y FALSO de forma predeterminada, pero no son palabras reservadas y, por
lo tanto, el usuario puede sobrescribirlas. Por lo tanto, siempre debes usar VERDADERO y FALSO.
Los vectores lógicos son generados por condiciones. Por ejemplo
> temp < x > 13
establece temp como un vector de la misma longitud que x con valores FALSO correspondientes a elementos de x
donde no se cumple la condición y VERDADERO donde sí se cumple.
Los operadores lógicos son <, <=, >, >=, == para igualdad exacta y != para desigualdad. Además, si c1 y c2
son expresiones lógicas, entonces c1 y c2 son sus intersecciones (“y”), c1 | c2 es su unión (“o”) y !c1 es la
negación de c1.
Los vectores lógicos se pueden usar en aritmética ordinaria, en cuyo caso se convierten en vectores
numéricos, FALSO se convierte en 0 y VERDADERO en 1. Sin embargo, hay situaciones en las que los vectores
lógicos y sus contrapartes numéricas coaccionadas no son equivalentes; por ejemplo, consulte la siguiente
subsección.
2.5 Valores faltantes

En algunos casos, es posible que no se conozcan completamente los componentes de un vector. Cuando un
elemento o valor está “no disponible” o es un “valor faltante” en el sentido estadístico, se le puede reservar un
lugar dentro de un vector asignándole el valor especial NA. En general, cualquier operación sobre una NA se
convierte en una NA. La motivación de esta regla es simplemente que si la especificación de una operación es
incompleta, el resultado no puede conocerse y, por tanto, no está disponible.
La función is.na(x) da un vector lógico del mismo tamaño que x con valor VERDADERO si y
sólo si el elemento correspondiente en x es NA.
>z<c(1:3,NA); ind < es.na(z)
Observe que la expresión lógica x == NA es bastante diferente de is.na(x) ya que NA no es realmente un valor
sino un marcador de una cantidad que no está disponible. Por lo tanto, x == NA es un vector de la misma longitud
que x, todos cuyos valores son NA, ya que la expresión lógica en sí misma es incompleta y, por lo tanto, indecidible.
Tenga en cuenta que existe un segundo tipo de valores “faltantes” que se producen mediante cálculo
numérico, los llamados valores que no son un número, NaN. Ejemplos son
> 0/0
o
> Inf Inf
los cuales dan NaN ya que el resultado no se puede definir de manera sensata.
En resumen, is.na(xx) es VERDADERO tanto para los valores NA como para NaN. Para diferenciarlos, is.nan(xx)
solo es VERDADERO para NaN.
Los valores faltantes a veces se imprimen como <NA> cuando los vectores de caracteres se imprimen sin comillas.
2.6 Vectores de caracteres

Las cantidades de caracteres y los vectores de caracteres se utilizan con frecuencia en R, por ejemplo, como etiquetas de trazado.
Cuando es necesario, se indican mediante una secuencia de caracteres delimitados por comillas dobles, por ejemplo,
"valores x", "Resultados de nueva iteración".
Las cadenas de caracteres se ingresan usando comillas dobles (") o simples (') coincidentes, pero se imprimen
usando comillas dobles (o a veces sin comillas). Usan secuencias de escape estilo C, usando \ como carácter de escape,
"
por lo que \\ es ingresado e impreso como \\, y entre comillas dobles se ingresa como \". Otras secuencias de escape
útiles son \n, nueva línea, \t, tabulación y \b, retroceso; consulte ?Comillas para obtener una lista completa.
Los vectores de caracteres se pueden concatenar en un vector mediante la función c(); Con frecuencia surgirán
ejemplos de su uso.
La función pegar() toma un número arbitrario de argumentos y los concatena uno por uno en cadenas de caracteres.
Cualquier número dado entre los argumentos se convierte en cadenas de caracteres de manera evidente, es decir, de la
misma manera que lo serían si estuvieran impresos. Los argumentos están separados de forma predeterminada en el
resultado por un único carácter en blanco, pero esto se puede cambiar mediante el argumento nombrado, sep=string, que
lo cambia a una cadena, posiblemente vacía.
Por ejemplo >
labs < pegar(c("X","Y"), 1:10, sep="") convierte labs en el
vector de caracteres
c("X1", "Y2", "X3", "Y4", "X5", "Y6", "X7", "Y8", "X9", "Y10")
Cabe señalar en particular que aquí también se reciclan las listas cortas; por lo tanto c("X", "Y") es
Se repite 5 veces para que coincida con la secuencia 1:10.3
2.7 vectores índice; seleccionar y modificar subconjuntos de un conjunto de datos

Se pueden seleccionar subconjuntos de elementos de un vector añadiendo al nombre del vector un vector índice entre
corchetes. De manera más general, cualquier expresión que se evalúe como un vector puede tener subconjuntos de sus
elementos seleccionados de manera similar agregando un vector índice entre corchetes inmediatamente después de la
expresión.
Dichos vectores de índice pueden ser cualquiera de cuatro tipos distintos.
1. Un vector lógico. En este caso, el vector índice se recicla a la misma longitud que el vector del que se van a
seleccionar los elementos. Se seleccionan los valores correspondientes a VERDADERO en el vector índice y se
omiten los correspondientes a FALSO. Por ejemplo > y < x[!is.na(x)] crea (o recrea) un
objeto y que contendrá los
valores no faltantes de x, en el mismo orden. Tenga en cuenta que si a x le faltan valores, y será más corto que x.
También
> (x+1)[(!is.na(x)) & x>0] > z
crea un objeto z y coloca en él los valores del vector x+1 para los cuales el valor correspondiente en x era positivo
y no faltante.
3
pegar(..., colapsar=ss) une los argumentos en una cadena de un solo carácter colocando ss en el medio, por ejemplo, ss
< "|". Hay más herramientas para la manipulación de caracteres; consulte la ayuda para sub y subcadena.
2. Un vector de cantidades integrales positivas. En este caso, los valores del vector índice deben estar en el conjunto
{1, 2, . . ., longitud(x)}.Los elementos correspondientes del vector se seleccionan y concatenan, en ese orden, en
el resultado. El vector índice puede tener cualquier longitud y el resultado tiene la misma longitud que el vector
índice. Por ejemplo x[6] es el sexto componente de x y
>x[1:10]
selecciona los primeros 10 elementos de x (asumiendo que la longitud (x) no es menor que 10).
También > c("x","y")[rep(c(1,2,2,1), veces=4)]
(algo ciertamente poco probable) produce un vector de caracteres de longitud 16 que consta de "x", "y", "y", "x"
repetido cuatro veces.
3. Un vector de cantidades integrales negativas. Un vector de índice de este tipo especifica los valores que se
excluidos en lugar de incluidos. De este modo
> y < x[(1:5)] da y

todos menos los primeros cinco elementos de x.
4. Un vector de cadenas de caracteres. Esta posibilidad sólo se aplica cuando un objeto tiene un atributo de nombres
para identificar sus componentes. En este caso, se puede usar un subvector del vector de nombres de la misma
manera que las etiquetas integrales positivas en el punto 2 más arriba.
> fruta < c(5, 10, 1, 20) > nombres(fruta)
< c("naranja", "plátano", "manzana", "melocotón") > almuerzo <
fruta[c("manzana" ,"naranja")]
La ventaja es que los nombres alfanuméricos suelen ser más fáciles de recordar que los índices numéricos. Esta
opción es particularmente útil en relación con marcos de datos, como veremos más adelante.
Una expresión indexada también puede aparecer en el extremo receptor de una asignación, en cuyo caso la
operación de asignación se realiza solo en esos elementos del vector. La expresión debe tener la forma
vector[index_vector] ya que tener una expresión arbitraria en lugar del nombre del vector no tiene mucho sentido aquí.
Por ejemplo >

x[is.na(x)] < 0
reemplaza cualquier valor faltante en x por ceros y > y[y

< 0] < y[y < 0]
tiene el mismo efecto que
> y < abs(y)
2.8 Otros tipos de objetos Los vectores son el
tipo de objeto más importante en R, pero hay varios otros que veremos más formalmente en secciones posteriores.
• las matrices o más generalmente los arreglos son generalizaciones multidimensionales de vectores. De hecho, son
vectores que pueden indexarse mediante dos o más índices y se imprimirán de forma especial. Consulte el
Capítulo 5 [Arreglos y matrices], página 18.
• Los factores proporcionan formas compactas de manejar datos categóricos. Consulte el Capítulo 4 [Factores],
página 16. • Las listas son una forma general de vector en la que los diversos elementos no necesitan ser del mismo
tipo y, a menudo, son en sí mismos vectores o listas. Las listas proporcionan una manera conveniente de devolver
los resultados de un cálculo estadístico. Consulte la Sección 6.1 [Listas], página 26. •
Los marcos de datos son estructuras similares a matrices, en las que las columnas pueden ser de diferentes tipos.
Piense en los marcos de datos como 'matrices de datos' con una fila por unidad de observación pero con (posiblemente)
variables tanto numéricas como categóricas. Muchos experimentos se describen mejor mediante marcos
de datos: los tratamientos son categóricos pero la respuesta es numérica. Consulte la Sección 6.3 [Marcos
de datos], página 27.
• las funciones son en sí mismas objetos en R que pueden almacenarse en el espacio de trabajo del proyecto.
Esto proporciona una forma sencilla y cómoda de ampliar R. Consulte el Capítulo 10 [Escribir sus propias
funciones], página 42.
Capítulo 3: Objetos, sus modos y atributos. 13
3 Objetos, sus modos y atributos
3.1 Atributos intrínsecos: modo y longitud Las entidades sobre las que
opera R se conocen técnicamente como objetos. Algunos ejemplos son vectores de valores numéricos
(reales) o complejos, vectores de valores lógicos y vectores de cadenas de caracteres. Éstas se conocen
como estructuras “atómicas” ya que sus componentes son todos del mismo tipo o modo, es decir, numéricos1 ,
complejos,lógicos, de carácter y sin formato.
Los vectores deben tener todos sus valores del mismo modo. Por lo tanto, cualquier vector dado debe
ser inequívocamente lógico, numérico, complejo, de caracteres o sin formato. (La única excepción aparente a
esta regla es el “valor” especial que figura como NA para cantidades no disponibles, pero de hecho existen
varios tipos de NA). Tenga en cuenta que un vector puede estar vacío y aún tener una moda. Por ejemplo, el
vector de cadena de caracteres vacío aparece como carácter(0) y el vector numérico vacío como numérico(0).
R también opera sobre objetos llamados listas, que son del modo lista. Son secuencias ordenadas de
objetos que individualmente pueden ser de cualquier modo. Las listas se conocen como estructuras
“recursivas” en lugar de atómicas, ya que sus componentes pueden ser listas por derecho propio.
Las otras estructuras recursivas son las de función modal y expresión. Las funciones son los objetos que
forman parte del sistema R junto con funciones similares escritas por el usuario, que analizaremos con cierto
detalle más adelante. Las expresiones como objetos forman una parte avanzada de R que no se analizará en
esta guía, excepto indirectamente cuando analicemos las fórmulas utilizadas con el modelado en R.
Por modo de un objeto entendemos el tipo básico de sus constituyentes fundamentales. Este es un caso
especial de "propiedad" de un objeto. Otra propiedad de todo objeto es su longitud. Las funciones modo(objeto)
y longitud(objeto) se pueden utilizar para averiguar el modo y la longitud de cualquier estructura definida2 .
Otras propiedades de un objeto generalmente las proporcionan los atributos (objeto), consulte la Sección
3.3 [Obtener y configurar atributos], página 14. Debido a esto, el modo y la longitud también se denominan
"atributos intrínsecos" de un objeto.
Por ejemplo, si z es un vector complejo de longitud 100, entonces en un modo de expresión (z) la cadena
de caracteres es "compleja" y la longitud (z) es 100.
R permite cambios de modo en casi cualquier lugar donde se pueda considerar sensato hacerlo (y algunos
donde podría no serlo). Por ejemplo con
> z < 0:9
podríamos
poner > dígitos < as.character(z)
después de los cuales dígitos está el vector de caracteres c("0", "1", "2", ..., "9"). Una coerción adicional, o
cambio de modo, reconstruye nuevamente el vector numérico: >
d < as.integer(digits)
Ahora d y z son lo mismo.3 Hay una gran colección de funciones de la forma as.something() para coerción
de un modo a otro o para investir a un objeto con algún otro atributo que tal vez no posea ya. El lector deberá
consultar los diferentes archivos de ayuda para familiarizarse con ellos.
1
El modo numérico es en realidad una amalgama de dos modos distintos, a saber, entero y de doble precisión, como se explica en
el manual.
2
Sin embargo, tenga en cuenta que longitud (objeto) no siempre contiene información útil intrínseca, por ejemplo, cuando el objeto
es una función.
3
En general, la coerción de un número a un carácter y viceversa no será exactamente reversible debido a errores de redondeo en la
representación de los caracteres.
3.2 Cambiar la longitud de un objeto

Un objeto "vacío" todavía puede tener un modo. Por ejemplo
> e < numérico()
convierte a e en una estructura vectorial vacía de modo numérico. De manera similar, caracter() es un vector de caracteres
vacío, y así sucesivamente. Una vez que se ha creado un objeto de cualquier tamaño, se le pueden agregar nuevos
componentes simplemente dándole un valor de índice fuera de su rango anterior. De este modo
> e[3] < 17
ahora forma un vector de longitud 3 (cuyos dos primeros componentes son en este punto ambos NA).
Esto se aplica a cualquier estructura, siempre que el modo de los componentes adicionales concuerde con el modo del
objeto en primer lugar.
Este ajuste automático de las longitudes de un objeto se utiliza a menudo, por ejemplo en la función scan() para
entrada. (consulte la Sección 7.2 [La función scan()], página 31.)
Por el contrario, para truncar el tamaño de un objeto sólo se requiere una asignación para hacerlo. Por lo tanto, si alfa
es un objeto de longitud 10, entonces > alfa <
alfa[2 * 1:5]
lo convierte en un objeto de longitud 5 que consta solo de los componentes anteriores con índice par. (Los índices
antiguos no se conservan, por supuesto). Entonces podemos conservar sólo los primeros tres valores mediante
> longitud (alfa) < 3
y los vectores se pueden ampliar (mediante valores faltantes) de la misma manera.
3.3 Obtener y configurar atributos La función atributos (objeto)
devuelve una lista de todos los atributos no intrínsecos actualmente definidos para ese objeto. La función attr(objeto,
nombre) se puede utilizar para seleccionar un atributo específico. Estas funciones rara vez se utilizan, excepto en
circunstancias bastante especiales cuando se crea algún atributo nuevo para algún propósito particular, por ejemplo, para
asociar una fecha de creación o un operador con un objeto R. El concepto, sin embargo, es muy importante.
Se debe tener cierto cuidado al asignar o eliminar atributos, ya que son una parte integral del sistema de objetos
utilizado en R.
Cuando se utiliza en el lado izquierdo de una tarea, se puede utilizar para asociar una
nuevo atributo con objeto o para cambiar uno existente. Por ejemplo
> atributo(z, "tenue") < c(10,10)
permite a R tratar z como si fuera una matriz de 10 por 10.
3.4 La clase de un objeto Todos los objetos en
R tienen una clase, informada por la clase de función. Para vectores simples, este es solo el modo, por ejemplo,
"numérico", "lógico", "carácter" o "lista", pero "matriz", "matriz", "factor" y "marco.de.datos" son otros valores posibles.
Se utiliza un atributo especial conocido como clase del objeto para permitir un estilo de programación4 orientado a
objetos en R. Por ejemplo, si un objeto tiene la clase "data.frame", se imprimirá de cierta manera, el diagrama ( ) la función
lo mostrará gráficamente de cierta manera, y otras funciones denominadas genéricas como resumen() reaccionarán ante
él como un argumento de una manera sensible a su clase.
Para eliminar temporalmente los efectos de la clase, utilice la función unclass(). Por ejemplo si es invierno
tiene la clase "data.frame" entonces
4
En los métodos del paquete se proporciona un estilo diferente que utiliza clases 'formales' o 'S4'.
> invierno
lo imprimirá en forma de marco de datos, que es más bien como una matriz, mientras que
> sin clase (invierno)
lo imprimirá como una lista normal. Sólo en situaciones bastante especiales es necesario utilizar esta función, pero una
es cuando estás aprendiendo a aceptar la idea de clase y funciones genéricas.
Las funciones y clases genéricas se analizarán con más detalle en la Sección 10.9 [Orientación a objetos], página
49, pero sólo brevemente.
Capítulo 4: Factores ordenados y desordenados dieciséis
4 factores ordenados y desordenados
Un factor es un objeto vectorial que se utiliza para especificar una clasificación (agrupación) discreta de los componentes
de otros vectores de la misma longitud. R proporciona factores tanto ordenados como desordenados. Si bien la aplicación
“real” de factores es con fórmulas modelo (consulte la Sección 11.1.1 [Contrastes], página 53), aquí analizamos un
ejemplo específico.
4.1 Un ejemplo específico

Supongamos, por ejemplo, que tenemos una muestra de 30 contadores fiscales de todos los estados y territorios de
Australia1 y su estado de origen individual se especifica mediante un vector de caracteres de mnemónicos estatales
como
> estado < c("tas", "sa", "qld", "nsw", "nsw", "nt", "wa", "wa", "qld", "vic", "nsw", "vic", "qld", "qld", "sa",
"tas", "sa", "nt", "wa", "vic", "qld", "nsw", "nsw", "wa ", "sa", "actuar", "nsw", "vic",
"vic", "actuar")
Observe que en el caso de un vector de caracteres, "ordenado" significa ordenado en orden alfabético.
Un factor se crea de manera similar usando la función factor():
> estadof < factor(estado)
La función print() maneja factores de manera ligeramente diferente a otros objetos:

> estado
[1] tas sa qld nsw nsw nt wa wa qld vic nsw vic qld qld sa [16] tas sa nt wa vic qld nsw nsw wa
sa act nsw vic vic act
Niveles: act nsw nt qld sa tas vic wa
Para conocer los niveles de un factor se puede utilizar la función niveles().
> niveles(statef) [1]
"actuar" "nsw" "nt" "qld" "sa" "tas" "vic" "wa"
4.2 La función tapply() y ragged arrays Para continuar con el ejemplo anterior,
supongamos que tenemos los ingresos de los mismos contadores fiscales en otro vector (en unidades de dinero
adecuadamente grandes)
> ingresos < c(60, 49, 40, 61, 64, 60, 59, 54, 62, 69, 70, 42, 56, 61, 61, 61, 58, 51, 48, 65, 49, 49,
41, 48, 52, 46, 59, 46, 58, 43)
Para calcular el ingreso medio muestral para cada estado ahora podemos usar la función especial tapply():
> incmeans < tapply(ingresos, estado, media) dando un vector

de medias con los componentes etiquetados por los niveles
acto qld
Nueva Gales del Sur en eso
Nuevo Testamento víctima de
44.500 57.333 55.500 53.600 55.000 60.500 56.000 52.250
La función tapply() se utiliza para aplicar una función, aquí mean(), a cada grupo de componentes del primer
argumento, aquí ingresos, definidos por los niveles del segundo componente, aquí statef2 ,
1
Los lectores deben tener en cuenta que hay ocho estados y territorios en Australia, a saber, el Territorio de la Capital Australiana,
Nueva Gales del Sur, el Territorio del Norte, Queensland, Australia del Sur, Tasmania, Victoria y Australia Occidental.
2
Tenga en cuenta que tapply() también funciona en este caso cuando su segundo argumento no es un factor, por ejemplo,
'tapply(ingresos, estado)', y esto es cierto para muchas otras funciones, ya que los argumentos se fuerzan a factores cuando es
necesario ( usando as.factor()).
Capítulo 4: Factores ordenados y desordenados 17
como si fueran estructuras vectoriales separadas. El resultado es una estructura de la misma longitud que el atributo de niveles
del factor que contiene los resultados. El lector debe consultar el documento de ayuda para obtener más detalles.
Supongamos además que necesitábamos calcular los errores estándar de las medias de ingresos estatales. Para hacer
esto necesitamos escribir una función R para calcular el error estándar de cualquier vector dado. Dado que existe una función
incorporada var() para calcular la varianza de la muestra, dicha función es muy simple, especificada por la asignación: > stderr
< function(x) sqrt(var(x)/length(x))
(La escritura de funciones se considerará más adelante en el Capítulo 10 [Escribir sus propias funciones], página 42, y en este
caso no fue necesaria ya que R también tiene una función incorporada sd().) Después de esta asignación, los errores estándar
se calculan mediante > incster < tapply(ingresos,
statef, stderr)
y los valores calculados son entonces
> incluir
acto qld
Nueva Gales del Sur sa tas vic de
1,5 4,3102 4,5 4,1061 2,7386 0,5 5,244 2,6575
Como ejercicio, tal vez le interese encontrar los límites de confianza habituales del 95% para los ingresos medios estatales.
Para hacer esto, puede usar tapply() una vez más con la función length() para encontrar los tamaños de muestra y la función
qt() para encontrar los puntos porcentuales de las distribuciones t apropiadas. (También podría investigar las instalaciones de
R para las pruebas t).
La función tapply() también se puede utilizar para manejar una indexación más complicada de un vector por múltiples
categorías. Por ejemplo, podríamos desear dividir a los contadores fiscales por estado y sexo. Sin embargo, en este simple
ejemplo (sólo un factor), lo que sucede se puede considerar de la siguiente manera. Los valores del vector se recopilan en
grupos correspondientes a las distintas entradas del factor. Luego, la función se aplica a cada uno de estos grupos
individualmente. El valor es un vector de resultados de la función, etiquetado por el atributo de niveles del factor.
La combinación de un vector y un factor de etiquetado es un ejemplo de lo que a veces se denomina matriz irregular, ya
que los tamaños de las subclases posiblemente sean irregulares. Cuando los tamaños de las subclases son todos iguales, la
indexación se puede realizar de forma implícita y mucho más eficiente, como veremos en la siguiente sección.
4.3 Factores ordenados

Los niveles de factores se almacenan en orden alfabético, o en el orden en que se especificaron para factorizar si se
especificaron explícitamente.
A veces, los niveles tendrán un orden natural que queremos registrar y queremos que utilice nuestro análisis estadístico. La
función ordenada() crea dichos factores ordenados pero por lo demás es idéntica al factor. Para la mayoría de los propósitos, la
única diferencia entre factores ordenados y desordenados es que los primeros se imprimen mostrando el orden de los niveles,
pero los contrastes generados para ellos al ajustar modelos lineales son diferentes.
Capítulo 5: Matrices y matrices 18
5 Matrices y matrices
5.1 Matrices Una
matriz puede considerarse como una colección de entradas de datos con subíndices múltiples, por ejemplo numéricos.
R permite facilidades simples para crear y manejar matrices y, en particular, el caso especial de matrices.
Un vector de dimensión es un vector de números enteros no negativos. Si su longitud es k entonces la matriz es k

dimensional, por ejemplo, una matriz es una matriz bidimensional. Las dimensiones están indexadas desde uno hasta
los valores dados en el vector de dimensión.
R puede utilizar un vector como matriz solo si tiene un vector de dimensión como atributo tenue.
Supongamos, por ejemplo, que z es un vector de 1500 elementos. La asignación
> tenue(z) < c(3,5,100)
le da el atributo tenue que permite tratarlo como una matriz de 3 por 5 por 100.
Otras funciones como Matrix() y Array() están disponibles para funciones más sencillas y naturales.
buscando asignaciones, como veremos en la Sección 5.4 [La función array()], página 20.
Los valores en el vector de datos dan los valores en la matriz en el mismo orden en que aparecerían en FORTRAN,
es decir, "orden mayor de columna", con el primer subíndice moviéndose más rápido y el último subíndice más lento.
Por ejemplo, si el vector de dimensión de una matriz, digamos a, es c(3,4,2), entonces hay 3 × 4 × 2 = 24 entradas
en a y el vector de datos las contiene en el orden a[1,1, 1], un[2,1,1], ..., un[2,4,2], un[3,4,2].
Las matrices pueden ser unidimensionales: normalmente se tratan de la misma manera que los vectores (incluso
al imprimir), pero las excepciones pueden causar confusión.
5.2 Indexación de matrices. Subsecciones de una matriz

Se puede hacer referencia a los elementos individuales de una matriz dando el nombre de la matriz seguido de los
subíndices entre corchetes, separados por comas.
De manera más general, las subsecciones de una matriz se pueden especificar dando una secuencia de vectores
índice en lugar de subíndices; sin embargo, si a cualquier posición de índice se le asigna un vector de índice vacío, se
toma el rango completo de ese subíndice.
Continuando con el ejemplo anterior, a[2,,] es una matriz de 4 × 2 con vector de dimensión c(4,2) y
vector de datos que contiene los valores
c(a[2,1,1], a[2,2,1], a[2,3,1], a[2,4,1], a[2,1,2], a[2 ,2,2],

un[2,3,2], un[2,4,2])
en ese orden. a[,,] representa la matriz completa, lo que equivale a omitir los subíndices por completo y usar a solo.
Para cualquier matriz, digamos Z, se puede hacer referencia explícita al vector de dimensión como dim(Z) (en cualquiera de los dos casos).
lado de una tarea).
Además, si el nombre de una matriz se proporciona con solo un subíndice o vector de índice, entonces solo se
utilizan los valores correspondientes del vector de datos; en este caso se ignora el vector de dimensión. Sin embargo,
este no es el caso si el índice único no es un vector sino una matriz en sí misma, como veremos a continuación.
5.3 Matrices de índice

Además de un vector índice en cualquier posición de subíndice, se puede utilizar una matriz con un único índice.
matriz para asignar un vector de cantidades a una colección irregular de elementos en
la matriz, o para extraer una colección irregular como un vector.
Un ejemplo de matriz aclara el proceso. En el caso de una matriz doblemente indexada, un índice
Se puede proporcionar una matriz que consta de dos columnas y tantas filas como se desee. Las entradas en el
La matriz de índice son los índices de filas y columnas de la matriz doblemente indexada. Supongamos por ejemplo
Tenemos una matriz X de 4 por 5 y deseamos hacer lo siguiente:
• Extraer los elementos X[1,3], X[2,2] y X[3,1] como una estructura vectorial, y
• Reemplace estas entradas en la matriz X por ceros.
En este caso necesitamos una matriz de subíndices de 3 por 2, como en el siguiente ejemplo.
> x < array(1:20, dim=c(4,5)) # Genera una matriz de 4 por 5.
>x
[,1] [,2] [,3] [,4] [,5]
[1,] 1 5 9 13 17
[2,] 2 6 10 14 18
[3,] 3 7 11 15 19
[4,] 4 8 12 16 20
> i < matriz(c(1:3,3:1), dim=c(3,2))
> yo # i es una matriz de índice de 3 por 2.
[,1] [,2]
[1,] 1 3
[2,] 2 2
[3,] 3 1
> x[i] [1] # Extraer esos elementos
963
> x[yo] < 0 # Reemplazar esos elementos por ceros.
>x
[,1] [,2] [,3] [,4] [,5]
[1,] 1 5 0 13 17
[2,] 2 0 10 14 18
[3,] 0 7 11 15 19
[4,] 4 8 12 16 20
>
No se permiten índices negativos en matrices de índices. Se permiten valores NA y cero: filas en el

Las matrices de índice que contienen un cero se ignoran y las filas que contienen un NA producen un NA en el
resultado.
Como ejemplo menos trivial, supongamos que deseamos generar una matriz de diseño (no reducida) para un
Diseño de bloques definidos por bloques de factores (niveles b) y variedades (niveles v). Supongamos además
hay n parcelas en el experimento. Podríamos proceder de la siguiente manera:
> Xb < matriz(0, n, b)
> Xv < matriz(0, n, v)
> ib < cbind(1:n, bloques)
> iv < cbind(1:n, variedades)
> Xb[uno] < 1
> XV[iv] < 1
> X < cbind(Xb, Xv)
Para construir la matriz de incidencia, digamos N, podríamos usar
> N < crossprod(Xb, Xv)
Sin embargo, una forma directa más sencilla de producir esta matriz es utilizar la tabla():
> N < tabla(bloques, variedades)
Las matrices de índice deben ser numéricas: cualquier otra forma de matriz (por ejemplo, lógica o de caracteres).
matriz) suministrada como matriz se trata como un vector de indexación.
5.4 La función array() Además de darle a una
estructura vectorial un atributo tenue, se pueden construir matrices a partir de vectores mediante la función array, que
tiene la forma
> Z < matriz(vector_datos, vector_dim)
Por ejemplo, si el vector h contiene 24 números o menos, entonces el comando
> Z < matriz(h, tenue=c(3,4,2))
usaría h para configurar una matriz de 3 por 4 por 2 en Z. Si el tamaño de h es exactamente 24, el resultado es el mismo
como
>Z<h; tenue(Z) < c(3,4,2)
Sin embargo, si h es más corto que 24, sus valores se reciclan desde el principio nuevamente para alcanzar el
tamaño 24 (consulte la Sección 5.4.1 [La regla de reciclaje], página 20) pero dim(h) < c(3,4 ,2) indicaría un error por
longitud no coincidente. Como ejemplo extremo pero común
> Z < matriz(0, c(3,4,2))
hace que Z sea una matriz de todos ceros.
En este punto, dim(Z) representa el vector de dimensión c(3,4,2), y Z[1:24] representa el vector de datos tal como
estaba en h, y Z[] con un subíndice vacío o Z con ningún subíndice representa la matriz completa como una matriz.
Las matrices se pueden utilizar en expresiones aritméticas y el resultado es una matriz formada por operaciones
elemento por elemento en el vector de datos. Los atributos tenues de los operandos generalmente deben ser los mismos
y esto se convierte en el vector de dimensión del resultado. Entonces, si A, B y C son matrices similares, entonces
> D < 2*A*B + C + 1
hace que D sea una matriz similar con su vector de datos como resultado de las operaciones elemento por elemento
dadas. Sin embargo, la regla precisa relativa a los cálculos vectoriales y de matrices mixtas debe considerarse con más
cuidado.
5.4.1 Aritmética mixta vectorial y matricial. La regla de reciclaje La regla precisa que afecta los cálculos
mixtos elemento por elemento con vectores y matrices es algo peculiar y difícil de encontrar en las referencias. Por
experiencia hemos descubierto que lo siguiente es una guía confiable.
• La expresión se escanea de izquierda a derecha. •
Cualquier operando vectorial corto se extiende reciclando sus valores hasta que coincidan con el tamaño.
de cualquier otro operando.
• Siempre que solo se encuentren vectores cortos y matrices, todas las matrices deben tener el mismo
atributo tenue o se producirá un error.
• Cualquier operando vectorial más largo que un operando de matriz o matriz genera un error. • Si hay
estructuras de matriz presentes y no se ha precipitado ningún error o coerción al vector, el resultado es una estructura
de matriz con el atributo tenue común de sus operandos de matriz.
5.5 El producto exterior de dos matrices.

Una operación importante en matrices es el producto exterior. Si a y b son dos matrices numéricas, su producto
exterior es una matriz cuyo vector de dimensiones se obtiene concatenando sus dos vectores de dimensiones (el
orden es importante), y cuyo vector de datos se obtiene formando todos los productos posibles de elementos del
vector de datos de a con los de b. El producto exterior está formado por el operador especial %o%:
> ab < a %o% b

Una alternativa es
> ab < exterior(a, b, "*")
La función de multiplicación se puede reemplazar por una función arbitraria de dos variables. Para
2
Por ejemplo, si quisiéramos evaluar la función f(x; y) = cos(y)/(1 + x valores con ) sobre una cuadrícula regular de
coordenadas x e y definidas por los R vectores x e y respectivamente, podríamos proceder de la siguiente manera:
> f < función(x, y) cos(y)/(1 + x^2) > z < exterior(x, y,

f)
En particular, el producto exterior de dos vectores ordinarios es una matriz con doble subíndice (es decir, una
matriz, de rango como máximo 1). Observe que el operador del producto externo, por supuesto, no es conmutativo.
La definición de sus propias funciones R se considerará más detalladamente en el Capítulo 10 [Escribir sus propias
funciones], página 42.
Un ejemplo: Determinantes de matrices de un solo dígito de 2 por 2. Como ejemplo artificial

pero lindo, considere los determinantes de matrices de 2 por 2 [a, b; c, d] donde cada entrada es un número entero
no negativo en el rango 0, 1,. . . , 9, eso es un dígito.
El problema es encontrar los determinantes, ad − bc, de todas las matrices posibles de esta forma y representar
la frecuencia con la que ocurre cada valor como un gráfico de alta densidad. Esto equivale a encontrar la
distribución de probabilidad del determinante si cada dígito se elige de forma independiente y uniforme al azar.
Una forma clara de hacer esto utiliza la función exterior() dos veces: >
d < exterior(0:9, 0:9) > fr <
tabla(exterior(d, d, "")) > plot(as.
numérico(nombres(fr)), fr, tipo="h", xlab="Determinante",
ylab="Frecuencia")
Nótese la coerción del atributo nombres de la tabla de frecuencia a numérico para recuperar el rango de los
valores determinantes. La forma “obvia” de resolver este problema con bucles for, que se analizará en el Capítulo
9 [Bucles y ejecución condicional], página 40, es tan ineficiente que resulta poco práctica.
Quizás también resulte sorprendente que aproximadamente 1 de cada 20 de estas matrices sea singular.
5.6 Transposición generalizada de una matriz

La función aperm(a, perm) se puede utilizar para permutar una matriz, a. El argumento permanente debe ser una
permutación de los números enteros {1, . . . , k}, donde k es el número de subíndices en a. El resultado de la
función es una matriz del mismo tamaño que a pero con la dimensión anterior dada por perm[j] convirtiéndose en
la nueva jésima dimensión. La forma más sencilla de considerar esta operación es como una generalización de la
transposición de matrices. De hecho, si A es una matriz (es decir, una matriz con doble subíndice), entonces B
está dada
por > B < aperm(A, c(2,1))
es solo la transpuesta de A. Para este caso especial está disponible una función más simple t(), por lo que
podríamos haber usado B < t(A).
5.7 Instalaciones matriciales

Como se señaló anteriormente, una matriz es simplemente una matriz con dos subíndices. Sin embargo, se trata de
un caso especial tan importante que necesita un debate aparte. R contiene muchos operadores y funciones que sólo
están disponibles para matrices. Por ejemplo, t(X) es la función de transposición de matriz, como se señaló anteriormente.
Las funciones nrow(A) y ncol(A) dan el número de filas y columnas de la matriz A respectivamente.
5.7.1 Multiplicación de matrices El operador
%*% se utiliza para la multiplicación de matrices. Por supuesto, se puede utilizar una matriz de n por 1 o de 1 por n
como vector n si en el contexto así es apropiado. Por el contrario, los vectores que aparecen en expresiones de
multiplicación de matrices se promocionan automáticamente a vectores de fila o de columna, lo que sea
multiplicativamente coherente, si es posible (aunque esto no siempre es posible sin ambigüedades, como veremos
más adelante).
Si, por ejemplo, A y B son matrices cuadradas del mismo tamaño, entonces
>A*B
es la matriz de productos elemento por elemento y

> A %*% B
es el producto de la matriz. Si x es un vector, entonces

> x %*% A %*% x es
una forma cuadrática.1

La función crossprod() forma "productos cruzados", lo que significa que crossprod(X, y) es lo mismo que t(X) %*%
y pero la operación es más eficiente. Si se omite el segundo argumento de crossprod(), se considera que es el mismo
que el primero.
El significado de diag() depende de su argumento. diag(v), donde v es un vector, da una matriz diagonal con
elementos del vector como entradas diagonales. Por otro lado, diag(M), donde M es una matriz, proporciona el vector
de entradas de la diagonal principal de M. Esta es la misma convención que se usa para diag() en Matlab. Además, de
manera algo confusa, si k es un valor numérico único, entonces diag(k) es la matriz de identidad k por k.
5.7.2 Ecuaciones lineales e inversión Resolver ecuaciones
lineales es la inversa de la multiplicación de matrices. Cuando después > b < A %*% x
sólo se dan A y b, el vector x es la solución de ese sistema de ecuaciones lineales. En R,

> resolver(A,b)
resuelve el sistema, devolviendo x (hasta cierta pérdida de precisión). Tenga en cuenta que en álgebra lineal,
formalmente x = A−1b donde A−1 denota la inversa de A, que puede calcularse mediante
resolver(A)
pero rara vez es necesario. Numéricamente, es ineficiente y potencialmente inestable calcular x < solve(A) %*% b en
lugar de solve(A,b).
La forma cuadrática x TA−1x que se utiliza en cálculos multivariados debe calcularse
por algo como2 x %*% resolver(A,x), en lugar de calcular la inversa de A.
1 T xxT , donde x es la forma de columna. En tal T

Tenga en cuenta que x %*% x es ambiguo, ya que podría significar x o
x es en este caso
que en x casos la matriz más pequeña parece implícitamente ser la interpretación adoptada, por lo que
el escalar x es el resultado. La matriz xxT se puede calcular mediante cbind(x) %*% x o x %*% rbind(x) ya que el resultado
T
rbind() o cbind() es siempre una matriz. Sin embargo, la mejor manera de calcular x xo de xxT es crossprod(x) o x
%o% x respectivamente.
2
Aún mejor sería formar una matriz raíz cuadrada B con A = BBT y encontrar la longitud al cuadrado de la solución de By =
x, tal vez usando la descomposición de Cholesky o propia de A.
5.7.3 Valores propios y vectores propios La función
eigen(Sm) calcula los valores propios y vectores propios de una matriz simétrica Sm. El resultado de esta función es
una lista de dos componentes llamados valores y vectores. La asignación > ev < eigen(Sm)
asignará esta lista a ev. Entonces ev$val es el vector de valores propios de Sm y ev$vec es la matriz de los vectores
propios correspondientes. Si solo necesitáramos los valores propios, podríamos haber usado la asignación:
> evaluaciones < valores propios(Sm)$

evals ahora contiene el vector de valores propios y el segundo componente se descarta. Si la expresión
> propio(Sm)
se usa solo como comando se imprimen los dos componentes, con sus nombres. Para matrices grandes es mejor
evitar calcular los vectores propios si no son necesarios mediante el uso de la expresión
> evaluaciones < eigen(Sm, solo.valores = VERDADERO)$valores
5.7.4 Descomposición en valores singulares y determinantes La función svd(M) toma un

argumento matricial arbitrario, M, y calcula la descomposición en valores singulares de M. Consiste en una matriz de
columnas ortonormales U con el mismo espacio de columnas que M, una segunda matriz de columnas ortonormales
V cuyo espacio de columnas es el espacio de filas de M y una matriz diagonal de entradas positivas D tal que M = U
%*% D %*% t(V). En realidad, D se devuelve como un vector de los elementos diagonales. El resultado de svd(M)
es en realidad una lista de tres componentes denominados d, u y v, con significados evidentes.
Si M es de hecho cuadrado, entonces no es difícil ver que

> absdetM < prod(svd(M)$d)
calcula el valor absoluto del determinante de M. Si este cálculo fuera necesario a menudo con una variedad de
matrices, podría definirse como una función R > absdet < function(M)
prod(svd(M)$d)
después de lo cual podríamos usar absdet() como una función más de R. Como otro ejemplo trivial pero
potencialmente útil, podría considerar escribir una función, digamos tr(), para calcular la traza de una matriz cuadrada.
[Sugerencia: no necesitará utilizar un bucle explícito. Mire nuevamente la función diag().]
R tiene una función incorporada det para calcular un determinante, incluido el signo, y otro,
determinante, para dar el signo y el módulo (opcionalmente en escala logarítmica),
5.7.5 Ajuste de mínimos cuadrados y descomposición QR La función lsfit() devuelve una

lista con los resultados de un procedimiento de ajuste de mínimos cuadrados. Una asignación como > ans < lsfit(X,
y) da los resultados de
un ajuste de mínimos
cuadrados donde y es el vector de observaciones y X es la matriz de diseño. Consulte la función de ayuda para
obtener más detalles y también para conocer la función de seguimiento ls.diag() para, entre otras cosas, diagnósticos
de regresión. Tenga en cuenta que un término de media general se incluye automáticamente y no es necesario
incluirlo explícitamente como una columna de X. Tenga en cuenta además que casi siempre preferirá usar lm(.)
(consulte la Sección 11.2 [Modelos lineales], página 54) a lsfit( ) para el modelado de regresión.
Otra función estrechamente relacionada es qr() y sus aliados. Considere las siguientes tareas
> Xplus < qr(X) > b <

qr.coef(Xplus, y) > fit <
qr.fitted(Xplus, y) > res < qr.resid(Xplus,
y)
Estos calculan la proyección ortogonal de y sobre el rango de X en ajuste, la proyección sobre el complemento
ortogonal en res y el vector de coeficientes para la proyección en b, es decir, b es esencialmente el resultado del
operador de 'barra invertida' de Matlab.
No se supone que X tenga el rango de columna completo. Los despidos serán descubiertos y eliminados.
tal como se encuentran.
Esta alternativa es la forma más antigua y de bajo nivel de realizar cálculos de mínimos cuadrados. Aunque sigue
siendo útil en algunos contextos, ahora generalmente sería reemplazado por las características de los modelos
estadísticos, como se discutirá en el Capítulo 11 [Modelos estadísticos en R], página 51.
5.8 Formación de matrices particionadas, cbind() y rbind()

Como ya hemos visto informalmente, las matrices se pueden construir a partir de otros vectores y matrices mediante
las funciones cbind() y rbind(). Aproximadamente, cbind() forma matrices uniendo matrices horizontalmente, o en
columnas, y rbind() verticalmente, o en filas.
en la tarea
> X < cbind(arg_1, arg_2, arg_3, ...)

los argumentos de cbind() deben ser vectores de cualquier longitud o matrices con el mismo tamaño de columna, es
decir, el mismo número de filas. El resultado es una matriz con los . formando las columnas. argumentos arg 1, arg
2,. .
Si algunos de los argumentos de cbind() son vectores, pueden ser más cortos que el tamaño de la columna de
cualquier matriz presente, en cuyo caso se extienden cíclicamente para que coincida con el tamaño de la columna
de la matriz (o la longitud del vector más largo si no se proporcionan matrices). ).
La función rbind() realiza la operación correspondiente para las filas. En este caso cualquier vector
argumento, posiblemente extendido cíclicamente, se toman, por supuesto, como vectores de fila.
Supongamos que X1 y X2 tienen el mismo número de filas. Para combinarlos por columnas en un
matriz X, junto con una columna inicial de unos podemos usar
> X < cbind(1, X1, X2)
El resultado de rbind() o cbind() siempre tiene estado de matriz. Por lo tanto, cbind(x) y rbind(x) son posiblemente
las formas más simples de permitir explícitamente que el vector x sea tratado como una matriz de columnas o filas,
respectivamente.
5.9 La función de concatenación, c(), con matrices

Cabe señalar que mientras que cbind() y rbind() son funciones de concatenación que respetan los atributos dim, la
función básica c() no lo hace, sino que borra los objetos numéricos de todos los atributos dim y dimnames. En
ocasiones, esto resulta útil por sí solo.
La forma oficial de convertir una matriz en un objeto vectorial simple es usar as.vector()
> vec < as.vector(X)
Sin embargo, se puede lograr un resultado similar usando c() con un solo argumento, simplemente por este
efecto secundario:
> cosa < c(X)
Hay ligeras diferencias entre los dos, pero en última instancia la elección entre ellos es
en gran medida una cuestión de estilo (siendo preferible lo primero).
5.10 Tablas de frecuencia a partir de factores

Recuerde que un factor define una partición en grupos. De manera similar, un par de factores definen dos
clasificación cruzada, etc. La función table() permite calcular tablas de frecuencia a partir de factores de longitud
iguales. Si hay k argumentos de factores, el resultado es una matriz de k vías de
frecuencias.
Supongamos, por ejemplo, que statef es un factor que proporciona el código de estado para cada entrada en una base de datos.
vector. La asignación
> estadofr < tabla(estadof)
da en statefr una tabla de frecuencias de cada estado en la muestra. Las frecuencias están ordenadas.
y etiquetado por el atributo de niveles del factor. Este caso simple es equivalente, pero más
conveniente que,
> statefr < tapply(statef, statef, longitud)
Supongamos además que el ingresof es un factor que da una “clase de ingreso” adecuadamente definida para cada
entrada en el vector de datos, por ejemplo con la función cut():
> factor(corte(ingresos, descansos = 35+10*(0:7))) > ingresosf
Luego para calcular una tabla de frecuencias de dos factores:
> tabla(ingresosf,estadof)
estado
ley de ingresos nsw nt qld sa tas vic wa
(35,45] 1 1010 10 0
(45,55] 1 11 12 0 13
(55,65] 0 3 1 3 2 2 21
(65,75] 0 10 00 0 10
La extensión a tablas de frecuencia de vías superiores es inmediata.

Capítulo 6: Listas y marcos de datos 26
6 Listas y marcos de datos
6.1 Listas
Una lista R es un objeto que consta de una colección ordenada de objetos conocidos como sus componentes.
No existe una necesidad particular de que los componentes sean del mismo modo o tipo y, por ejemplo, una lista
podría consistir en un vector numérico, un valor lógico, una matriz, un vector complejo, una matriz de caracteres, una
función y pronto. A continuación se muestra un ejemplo sencillo de cómo hacer una lista:
> Lst < lista(nombre="Fred", esposa="Mary", no.children=3, child.ages=c(4,7,9))
Los componentes siempre están numerados y siempre se puede hacer referencia a ellos como tales. Por lo tanto, si
Lst es el nombre de una lista con cuatro componentes, estos pueden denominarse individualmente Lst[[1]], Lst[[2]],
Lst[[3]] y Lst[[4]]. Si, además, Lst[[4]] es una matriz vectorial con subíndice, entonces Lst[[4]][1] es su primera entrada.
Si Lst es una lista, entonces la función length(Lst) proporciona la cantidad de componentes (nivel superior) que tiene.
También se pueden nombrar los componentes de las listas y, en este caso, se puede hacer referencia al componente
dando el nombre del componente como una cadena de caracteres en lugar del número entre corchetes dobles o, más
convenientemente, dando una expresión de la forma
> nombre$nombre_componente
por lo mismo.
Esta es una convención muy útil ya que hace que sea más fácil obtener el componente correcto si olvida el número.
Entonces, en el ejemplo simple dado arriba:
Lst$name es lo mismo que Lst[[1]] y es la cadena "Fred",
Lst$wife es lo mismo que Lst[[2]] y es la cadena "Mary",
Lst$child.ages[1] es lo mismo que Lst[[4]][1] y es el número 4.
Además, también se pueden utilizar los nombres de los componentes de la lista entre corchetes dobles, es decir,
Lst[["name"]] es lo mismo que Lst$name. Esto es especialmente útil cuando el nombre del componente a extraer se
almacena en otra variable como en
> x < "nombre"; Lista[[x]]
Es muy importante distinguir Lst[[1]] de Lst[1]. '[[...]]' es el operador utilizado para seleccionar un solo elemento,
mientras que '[...]' es un operador de subíndice general. Por tanto, el primero es el primer objeto de la lista Lst, y si es
una lista con nombre, el nombre no se incluye. Esta última es una sublista de la lista Lst que consta únicamente de la
primera entrada. Si se trata de una lista con nombres, los nombres se transfieren a la sublista.
Los nombres de los componentes pueden abreviarse hasta el número mínimo de letras necesarias para identificarlos
de forma única. Por lo tanto, los coeficientes Lst$ pueden especificarse mínimamente como Lst$coe y la Lst$covarianza
como Lst$cov.
De hecho, el vector de nombres es simplemente un atributo de la lista como cualquier otro y puede manejarse como
tal. Por supuesto, a otras estructuras además de las listas también se les puede dar un atributo de nombres.
6.2 Construir y modificar listas

Se pueden formar nuevas listas a partir de objetos existentes mediante la función list(). Una asignación de la forma
> Lst < list(name_1=object_1, ..., name_m=object_m) configura una lista Lst
de m componentes usando el objeto 1,. . ., objeto m para los componentes y dándoles nombres según lo especificado
por los nombres de los argumentos (que se pueden elegir libremente). Si se omiten estos nombres, los componentes
sólo están numerados. Los componentes utilizados para formar la lista se copian al formar la nueva lista y los originales
no se ven afectados.
Las listas, como cualquier objeto con subíndice, se pueden ampliar especificando componentes adicionales. Por
ejemplo
> Lst[5] < lista(matriz=Mat)
6.2.1 Concatenación de listas Cuando a la
función de concatenación c() se le dan argumentos de lista, el resultado también es un objeto del modo lista, cuyos
componentes son los de las listas de argumentos unidos en secuencia.
> lista.ABC < c(lista.A, lista.B, lista.C)
Recuerde que con objetos vectoriales como argumentos la función de concatenación unió de manera similar todos
los argumentos en una única estructura vectorial. En este caso, se descartan todos los demás atributos, como los
atributos tenues.
6.3 Marcos de datos

Un marco de datos es una lista con la clase "data.frame". Existen restricciones sobre las listas que pueden convertirse
en marcos de datos, a saber: •
Los componentes deben ser vectores (numéricos, de caracteres o lógicos), factores, matrices numéricas, listas u otros
marcos de datos.
• Las matrices, listas y marcos de datos proporcionan tantas variables al nuevo marco de datos como sean necesarias.
tener columnas, elementos o variables, respectivamente.
• Los vectores numéricos, lógicos y factores se incluyen tal cual y, de forma predeterminada, los vectores de 1 carácter
se fuerzan a ser factores, cuyos niveles son los valores únicos que aparecen en el vector. • Las estructuras
vectoriales que aparecen como variables del marco de datos deben tener todas la misma longitud,
y las estructuras matriciales deben tener todas el mismo tamaño de fila.
Para muchos propósitos, un marco de datos puede considerarse como una matriz con columnas posiblemente de
diferentes modos y atributos. Se puede mostrar en forma matricial y sus filas y columnas se pueden extraer utilizando
convenciones de indexación matricial.
6.3.1 Crear marcos de datos Los objetos
que satisfacen las restricciones impuestas a las columnas (componentes) de un marco de datos se pueden usar para
formar uno usando la función marco.datos:
> contadores < data.frame(casa=estadof, botín=ingresos, tiro=ingresosf)
Una lista cuyos componentes se ajustan a las restricciones de un marco de datos se puede convertir en un marco de
datos utilizando la función as.data.frame()
La forma más sencilla de construir un marco de datos desde cero es utilizar la función read.table() para leer un marco
de datos completo desde un archivo externo. Esto se analiza con más detalle en el Capítulo 7 [Lectura de datos de
archivos], página 30.
1
La conversión de columnas de caracteres a factores se anula utilizando el argumento stringsAsFactors para la
función data.frame().
6.3.2 adjuntar() y separar()

La notación $, como contadores$casa, para los componentes de la lista no siempre es muy conveniente.
Una función útil sería de alguna manera hacer que los componentes de una lista o marco de datos sean temporalmente
visibles como variables bajo el nombre de su componente, sin la necesidad de citar explícitamente el nombre de la lista
cada vez.
La función adjuntar() toma una 'base de datos', como una lista o un marco de datos, como argumento. Por lo tanto,
supongamos que lentejas es un marco de datos con tres variables lentejas$u, lentejas$v, lentejas$w. el adjunto
> adjuntar(lentejas)
coloca el marco de datos en la ruta de búsqueda en la posición 2, y siempre que no haya variables u, v o w en la posición
1, u, v y w están disponibles como variables del marco de datos por derecho propio.
En este punto una tarea como
> u < v+w
no reemplaza el componente u del marco de datos, sino que lo enmascara con otra variable u en el directorio de trabajo
en la posición 1 en la ruta de búsqueda. Para realizar un cambio permanente en el propio marco de datos, la forma más
sencilla es recurrir una vez más a la notación $:
> lentejas$u < v+w
Sin embargo, el nuevo valor del componente u no es visible hasta que el marco de datos se separa y se adjunta
nuevamente.
Para separar un marco de datos, use la función
> separar()
Más precisamente, esta declaración separa de la ruta de búsqueda la entidad actualmente en la posición 2. Por lo
tanto, en el contexto actual las variables u, v y w ya no serían visibles, excepto bajo la notación de lista como lentejas$u
y así sucesivamente. Las entidades en posiciones superiores a 2 en la ruta de búsqueda se pueden separar dando su
número para separar, pero es mucho más seguro usar siempre un nombre, por ejemplo, por detach(lentils) o
detach("lentils")
Nota: En R, las listas y los marcos de datos solo se pueden adjuntar en la posición 2 o superior, y lo que
se adjunta es una copia del objeto original. Puede modificar los valores adjuntos mediante asignación,
pero la lista o el marco de datos original no se modifica.
6.3.3 Trabajar con marcos de datos Una convención
útil que le permite trabajar cómodamente con muchos problemas diferentes juntos en el mismo directorio de trabajo es: •
reunir todas las variables para cualquier
problema bien definido y separado en un marco de datos
bajo un nombre adecuadamente informativo;
• cuando trabaje con un problema, adjunte el marco de datos apropiado en la posición 2 y use el directorio de trabajo
en el nivel 1 para cantidades operativas y variables temporales;
• antes de dejar un problema, agregue cualquier variable que desee conservar para referencia futura al
marco de datos utilizando la forma de asignación $ y luego separar();
• finalmente elimine todas las variables no deseadas del directorio de trabajo y manténgalo lo más limpio posible de
variables temporales sobrantes.
De esta manera es bastante sencillo trabajar con muchos problemas en el mismo directorio, todos los cuales
tener variables llamadas x, y y z, por ejemplo.
6.3.4 Adjuntar listas arbitrarias adjunto() es una
función genérica que permite no sólo adjuntar directorios y marcos de datos a la ruta de búsqueda, sino también otras
clases de objetos. En particular cualquier objeto del modo "lista" podrá adjuntarse de la misma forma:
> adjuntar(cualquier.lista.antigua)
Todo lo que se haya adjuntado se puede separar por desvinculación, por número de posición o, preferiblemente, por
nombre.
6.3.5 Administrar la ruta de búsqueda

La función de búsqueda muestra la ruta de búsqueda actual y, por lo tanto, es una forma muy útil de realizar un seguimiento de
qué marcos de datos y listas (y paquetes) se han adjuntado y separado. Inicialmente da
> buscar()
[1] ".GlobalEnv" "Cargas automáticas" "paquete:base"
donde .GlobalEnv es el espacio de trabajo.2
Después de unir las lentejas tenemos
> buscar()
[1] ".GlobalEnv" "lentejas" > ls(2) "Cargas automáticas" "paquete:base"
[1] "u" "v" "w"
y como vemos, ls (u objetos) se pueden usar para examinar el contenido de cualquier posición en la búsqueda.
camino.
Finalmente, separamos el marco de datos y confirmamos que se ha eliminado de la ruta de búsqueda.

> separar("lentejas")
> buscar()
[1] ".GlobalEnv" "Cargas automáticas" "paquete:base"
2
Consulte la ayuda en línea para la carga automática para conocer el significado del segundo término.
Capítulo 7: Lectura de datos de archivos 30
7 Leer datos de archivos

Los objetos de datos grandes generalmente se leerán como valores de archivos externos en lugar de ingresarse durante
una sesión de R en el teclado. Las instalaciones de entrada de R son simples y sus requisitos son bastante
estricto e incluso bastante inflexible. Existe una clara presunción por parte de los diseñadores de R de que usted
Podrá modificar sus archivos de entrada utilizando otras herramientas, como editores de archivos o Perl1 para que encajen.
con los requisitos de R. Generalmente esto es muy simple.
Si las variables se van a mantener principalmente en marcos de datos, como sugerimos encarecidamente que sea, una
El marco de datos completo se puede leer directamente con la función read.table(). También hay una más
Función de entrada primitiva, scan(), que se puede llamar directamente.
Para obtener más detalles sobre la importación de datos a R y también la exportación de datos, consulte R Data Im
puerto/manual de exportación.
7.1 La función read.table()

Para leer un marco de datos completo directamente, el archivo externo normalmente tendrá un formato especial.
• La primera línea del archivo debe tener un nombre para cada variable en el marco de datos.
• Cada línea adicional del archivo tiene como primer elemento una etiqueta de fila y los valores para cada
variable.
Si el archivo tiene un elemento menos en su primera línea que en su segunda, se presume esta disposición
estar vigente. Por lo tanto, las primeras líneas de un archivo que se leerán como un marco de datos podrían tener el siguiente aspecto.
Formulario de archivo de entrada con nombres y etiquetas de fila:
Precio Piso Área Habitaciones Edad Cent.calor

01 52.00 111.0 830 5 6.2 No
02 54,75 128.0 710 5 7.5 No
03 57,50 101.0 1000 5 4.2 No
04 57.50 131.0 690 6 8.8 No
05 59,75 93.0 900 5 1.9 Sí

...
De forma predeterminada, los elementos numéricos (excepto las etiquetas de fila) se leen como variables numéricas y no numéricas.
variables, como Cent.heat en el ejemplo, como factores. Esto se puede cambiar si es necesario.
La función read.table() puede usarse para leer el marco de datos directamente
> Precio de la vivienda < read.table("casas.data")
A menudo querrás omitir la inclusión de las etiquetas de las filas directamente y utilizar las etiquetas predeterminadas. En
En este caso, el archivo puede omitir la columna de etiqueta de fila como se muestra a continuación.
Formulario de archivo de entrada sin etiquetas de fila:
Precio Piso Área Habitaciones Edad Cent.calor

52.00 111.0 830 5 6.2 No
54,75 128.0 710 5 7.5 No
57,50 101.0 1000 5 4.2 No
57,50 131.0 690 6 8.8 No
59,75 93.0 900 5 1.9 Sí

...
1
En UNIX, se pueden utilizar las utilidades sed orawk.
El marco de datos se puede leer entonces

como > PrecioCasa < read.table("casas.data", encabezado=TRUE) donde la
opción encabezado=TRUE especifica que la primera línea es una línea de encabezados y, por lo tanto, por
implicación del forma del archivo, que no se proporcionan etiquetas de fila explícitas.
7.2 La función escanear()

Supongamos que los vectores de datos tienen la misma longitud y deben leerse en paralelo. Supongamos además
que hay tres vectores, el primero de modo carácter y los dos restantes de modo numérico, y el archivo es input.dat.
El primer paso es usar scan() para leer los tres vectores como una lista,
como sigue
> entrada < escaneo("entrada.dat", lista("",0,0))

El segundo argumento es una estructura de lista ficticia que establece la moda de los tres vectores a leer. El
resultado, contenido en inp, es una lista cuyos componentes son los tres vectores leídos. Para separar los
elementos de datos en tres vectores separados, use asignaciones como > etiqueta <
inp[[1]]; x < entrada[[2]]; y < entrada[[3]]
Más convenientemente, la lista ficticia puede tener componentes con nombre, en cuyo caso los nombres
se puede utilizar para acceder a los vectores leídos. Por ejemplo
> entrada < scan("input.dat", lista(id="", x=0, y=0))
Si desea acceder a las variables por separado, puede reasignarlas a variables en el marco de trabajo: >
etiqueta < inp$id; x <
entrada$x; y < entrada$y
o la lista puede adjuntarse en la posición 2 de la ruta de búsqueda (consulte la Sección 6.3.4 [Adjuntar listas
arbitrarias], página 28).
Si el segundo argumento es un valor único y no una lista, se lee un único vector, todos los componentes
del cual debe ser de la misma moda que el valor ficticio.
> X < matriz(scan("light.dat", 0), ncol=5, byrow=TRUE)
Hay opciones de entrada más elaboradas disponibles y se detallan en los manuales.
7.3 Acceso a conjuntos de datos integrados Alrededor
de 100 conjuntos de datos se suministran con R (en paquetes de conjuntos de datos) y otros están disponibles en
paquetes (incluidos los paquetes recomendados suministrados con R). Para ver la lista de conjuntos de datos
disponibles actualmente,
utilice data()
Todos los conjuntos de datos suministrados con R están disponibles directamente por nombre. Sin embargo, muchos paquetes
todavía usan la convención obsoleta en la que los datos también se usaban para cargar conjuntos de datos en R, por ejemplo
datos
y esto todavía se puede utilizar con los paquetes estándar (como en este ejemplo). En la mayoría de los casos,
esto cargará un objeto R con el mismo nombre. Sin embargo, en algunos casos carga varios objetos, así que
consulte la ayuda en línea del objeto para saber qué esperar.
7.3.1 Carga de datos de otros paquetes de R Para acceder a datos

de un paquete en particular, utilice el argumento del paquete, por ejemplo
datos(paquete="rpart")
datos(Puromicina, paquete="conjuntos de datos")
Si la biblioteca ha adjuntado un paquete, sus conjuntos de datos se incluyen automáticamente en la búsqueda.
Los paquetes aportados por los usuarios pueden ser una rica fuente de conjuntos de datos.
7.4 Editar datos

Cuando se invoca en un marco de datos o una matriz, editar muestra un entorno separado similar a una hoja de cálculo para
editar. Esto es útil para realizar pequeños cambios una vez que se ha leído un conjunto de datos. El comando > xnew <
edit(xold) le permitirá editar su
conjunto de datos xold y, al finalizar, el objeto modificado se asignará a xnew. Si desea modificar el conjunto de datos original
xold, la forma más sencilla es utilizar fix(xold), que equivale a xold <edit(xold).
Usar
> xnuevo < editar(data.frame())
para ingresar nuevos datos a través de la interfaz de la hoja de cálculo.

Capítulo 8: Distribuciones de probabilidad 33
8 distribuciones de probabilidad
8.1 R como conjunto de tablas estadísticas
Un uso conveniente de R es proporcionar un conjunto completo de tablas estadísticas. Las funciones son
proporcionado para evaluar la función de distribución acumulativa P (X ≤ x), la densidad de probabilidad
función y la función cuantil (dado q, el x más pequeño tal que P(X ≤ x) > q), y a
simular a partir de la distribución.
Distribución nombre R argumentos adicionales

beta beta forma1, forma2, ncp
binomio Algunos tamaño, problema
chisq ubicación, escala
Exponencial cauchy df, ncp
chicuadrado de Cauchy exp. tasa
F df1, df2, ncp
gamma gamma forma, escala
geométrica geom problema
hipergeométrica m, n, k
lognormal hipernormal registro medio, registro sd
logística logis ubicación, escala
negativa binomial nbinom tamaño, problema
normal norma significa, sd
Poison lambda
rango firmado porque norte
uniforme de signrank t df, ncp

estudiante unif mínimo máximo
Weibull weibull forma, escala
Wilcoxon wilcox metro, norte
Anteponga el nombre dado aquí con 'd' para la densidad, 'p' para la CDF, 'q' para la función cuantil
y 'r' para simulación (desviaciones aleatorias). El primer argumento es x para dxxx, q para pxxx, p para
qxxx y n para rxxx (excepto para rhyper, rsignrank y rwilcox, para los cuales es nn). En no
En casi todos los casos está disponible actualmente el parámetro de no centralidad ncp: consulte la ayuda en línea para
detalles.
Todas las funciones pxxx y qxxx tienen argumentos lógicos lower.tail y log.p y el
los dxxx tienen log. Esto permite, por ejemplo, obtener la función de riesgo acumulativo (o “integrado”),
H(t) = − log(1 − F(t)), por
pxxx(t,..., lower.tail = FALSO, log.p = VERDADERO)
o probabilidades logarítmicas más precisas (por dxxx(..., log = TRUE)), directamente.

Además existen funciones ptukey y qtukey para la distribución de los estudiantes
rango de muestras de una distribución normal, y dmultinom y rmultinom para la distribución multinomial
distribución. Hay más distribuciones disponibles en paquetes contribuidos, en particular SuppDists
(https://CRAN.Rproject.org/package=SuppDists).
Aquí hay unos ejemplos
> ## Valor p de 2 colas para la distribución t
> 2*pt(2,43, gl = 13)
> ## punto superior del 1% para una distribución F(2, 7)
> qf(0.01, 2, 7, cola.inferior = FALSO)
Consulte la ayuda en línea sobre RNG para saber cómo se realiza la generación de números aleatorios en R.
8.2 Examinar la distribución de un conjunto de datos Dado un conjunto de datos
(univariado), podemos examinar su distribución de muchas maneras. Lo más sencillo es examinar los números.
Se proporcionan dos resúmenes ligeramente diferentes mediante resumen y cinco números y una visualización de
los números por tallo (un gráfico de “tallo y hoja”).
> adjuntar(fiel) >

resumen(erupciones)
Mín. 1.er qu. Mediana Media 3.er qu. Máx.
1.600 2.163 4.000 3.488 4.454 5.100
> fivenum(erupciones) [1]
1.6000 2.1585 4.0000 4.4585 5.1000 > tallo(erupciones)
El punto decimal está 1 dígito(s) a la izquierda del |
16 | 070355555588 18 |
000022233333335577777777888822335777888 20 |
00002223378800035778 22 |
0002335578023578 24 |
00228 26 | 23
28 | 080
30 | 7 32 |
2337 34
| 250077 36
| 0000823577
38 | 2333335582225577
40 |
000000335778888800223355577778 42 |
03335555778800233333555577778 44 |
02222335557780000000023333357778888 46 |
0000233357700000023578 48 |
00000022335800333 50 | 0370
Un diagrama de tallo y hojas es como un histograma y R tiene una función hist para trazar histogramas.
> hist(erupciones) ##
hacer los contenedores más pequeños, hacer un gráfico
de densidad > hist(erupciones, seq(1.6, 5.2, 0.2), prob=TRUE) >
líneas(densidad(erupciones, bw=0.1)) >
rug( erupciones) # mostrar los puntos de datos reales
Se pueden crear gráficos de densidad más elegantes según la densidad, y en este ejemplo agregamos una línea
producida por la densidad. El ancho de banda bw se eligió mediante prueba y error como resultado predeterminado.
Demasiado suavizado (normalmente ocurre con densidades "interesantes"). (Mejores métodos automatizados de
Hay opciones de ancho de banda disponibles y, en este ejemplo, bw = "SJ" da un buen resultado).
Histograma de erupciones
aicnaevuictaelreFr
l lldllHHU~~I IIIICIOIIUnllU 11
1.5 2.0 2.5 3.0 3.5 4.0 4.5 5.0
erupciones
Podemos trazar la función de distribución acumulativa empírica utilizando la función ecdf.
> plot(ecdf(erupciones), do.points=FALSE, verticales=TRUE)
Esta distribución obviamente está lejos de cualquier distribución estándar. ¿Qué tal la mano derecha?
modo, digamos erupciones de más de 3 minutos? Ajustemos una distribución normal y superpongamos la
CDF instalado.
> largo < erupciones[erupciones > 3]

> plot(ecdf(long), do.points=FALSE, verticales=TRUE)
> x < secuencia (3, 5,4, 0,01)
> líneas(x, pnorm(x, media=media(larga), sd=sqrt(var(larga))), lty=3)
ECDF (largo)
)x(nF
3.0 3.5 4.0 4.5 5.0
Los gráficos cuantilcuantil (QQ) pueden ayudarnos a examinar esto más detenidamente.
par(pty="s") # organizar una región de figura cuadrada

qqnorm(largo); línea qq (larga)
lo que muestra un ajuste razonable pero una cola derecha más corta de lo que uno esperaría de un normal
distribución. Comparemos esto con algunos datos simulados de la distribución
Gráfico QQ normal

0.5
5.4
0.4
alritsneauuem
se C
d
5.3
0.3
−2 −1 0 1 2
Cuantiles teóricos
x < rt(250, gl = 5)
qqnorm(x); línea qq(x)
que normalmente (si se trata de una muestra aleatoria) mostrará colas más largas de lo esperado para una muestra normal. Nosotros
Puede hacer un gráfico QQ contra la distribución generadora mediante
qqplot(qt(ppoints(250), df = 5), x, xlab = "Gráfico QQ para t dsn")
línea qq(x)
Finalmente, podríamos querer una prueba más formal de acuerdo con la normalidad (o no). R proporciona
la prueba de ShapiroWilk
> shapiro.prueba (larga)
Prueba de normalidad de ShapiroWilk
datos: largos
W = 0,9793, valor p = 0,01052
y la prueba de KolmogorovSmirnov
> ks.test(largo, "pnorm", media = media(larga), sd = sqrt(var(larga)))
Prueba de KolmogorovSmirnov de una muestra
datos: largos
D = 0,0661, valor p = 0,4284
Hipótesis alternativa: bilateral.
(Tenga en cuenta que la teoría de la distribución no es válida aquí ya que hemos estimado los parámetros de la
distribución normal de la misma muestra).
8.3 Pruebas de una y dos muestras

Hasta ahora hemos comparado una única muestra con una distribución normal. Un mucho más común
La operación consiste en comparar aspectos de dos muestras. Tenga en cuenta que en R, todas las pruebas "clásicas", incluidas
los que se utilizan a continuación están en las estadísticas del paquete que normalmente se cargan.
Considere los siguientes conjuntos de datos sobre el calor latente de la fusión del hielo (cal/gm) de Rice
(1995, p.490)
Método A: 79,98 80,04 80,02 80,04 80,03 80,03 80,04 79,97

80,05 80,03 80,02 80,00 80,02
Método B: 80,02 79,94 79,98 79,97 79,97 80,03 79,95 79,97
Los diagramas de caja proporcionan una comparación gráfica simple de las dos muestras.
Un < escaneo()
79,98 80,04 80,02 80,04 80,03 80,03 80,04 79,97
80,05 80,03 80,02 80,00 80,02
B < escanear()
80,02 79,94 79,98 79,97 79,97 80,03 79,95 79,97
diagrama de caja (A, B)
lo que indica que el primer grupo tiende a dar resultados superiores al segundo.
~
40.08
1 1 ~
20.08
~; □
' '
00.08
89,97
69,97
49,97
1 2
Para probar la igualdad de las medias de los dos ejemplos, podemos usar una prueba t no apareada mediante
> t.prueba(A, B)
Prueba t de dos muestras de Welch
datos: A y B
t = 3,2499, gl = 12,027, valor p = 0,00694

Hipótesis alternativa: la verdadera diferencia de medias no es igual a 0.
Intervalo de confianza del 95 por ciento:
0,01385526 0,07018320
estimaciones de muestra:
media de x media de y
80.02077 79.97875
lo que sí indica una diferencia significativa, suponiendo normalidad. Por defecto, la función R no
no supone igualdad de varianzas en las dos muestras (a diferencia de la prueba t.SPlus similar
función). Podemos usar la prueba F para probar la igualdad en las varianzas, siempre que las dos
Las muestras provienen de poblaciones normales.
> var.prueba(A, B)
Prueba F para comparar dos varianzas

datos: A y B
F = 0,5837, num gl = 12, denom df = 7, valor p = 0,3938 hipótesis alternativa: la verdadera

relación de varianzas no es igual a 1 intervalo de confianza del 95 por ciento: 0,1251097 2,1052687
estimaciones muestrales:
ratio de varianzas
0.5837405
lo que no muestra evidencia de una diferencia significativa, por lo que podemos usar la prueba t clásica que supone igualdad de
las varianzas. > t.prueba(A, B,
var.equal=VERDADERO)
Prueba t de dos muestras
datos: A y B
t = 3,4722, gl = 19, valor p = 0,002551 hipótesis alternativa: la

verdadera diferencia de medias no es igual a 0 Intervalo de confianza del 95 por ciento:
0,01669058 0,06734788
estimaciones muestrales:
media de x media de y
80,02077 79,97875
Todas estas pruebas suponen la normalidad de las dos muestras. El Wilcoxon de dos muestras (o Mann
Whitney) solo supone una distribución continua común bajo la hipótesis nula. > prueba.wilcox(A, B)
Prueba de suma de rangos de Wilcoxon con corrección de continuidad
datos: A y B
W = 89, valor p = 0,007497 hipótesis

alternativa: el verdadero cambio de ubicación no es igual a 0
Mensaje de advertencia:
No se puede calcular el valor p exacto con vínculos en: wilcox.test(A, B)
Tenga en cuenta la advertencia: hay varios empates en cada muestra, lo que sugiere fuertemente que estos datos
provienen de una distribución discreta (probablemente debido al redondeo).
Hay varias formas de comparar gráficamente las dos muestras. Ya hemos visto un par de diagramas de caja. Lo siguiente
> plot(ecdf(A), do.points=FALSE,
verticals=TRUE, xlim=range(A, B)) > plot(ecdf(B), do.points=FALSE, verticals=TRUE, add=TRUE )

mostrará los dos CDF empíricos y qqplot realizará un gráfico QQ de las dos muestras. La
prueba de KolmogorovSmirnov es de la distancia vertical máxima entre los dos ECDF, suponiendo una distribución continua
común:
> ks.prueba(A, B)
Prueba de KolmogorovSmirnov de dos muestras
datos: A y B
D = 0,5962, valor p = 0,05919 hipótesis

alternativa: bilateral
Mensaje de advertencia:
no se pueden calcular los valores p correctos con vínculos en: ks.test(A, B)
Capítulo 9: Agrupación, bucles y ejecución condicional. 40
9 Agrupación, bucles y ejecución condicional.
9.1 Expresiones agrupadas R es un lenguaje
de expresiones en el sentido de que su único tipo de comando es una función o expresión que devuelve un
resultado. Incluso una asignación es una expresión cuyo resultado es el valor asignado, y puede usarse
dondequiera que se pueda usar cualquier expresión; en particular son posibles múltiples asignaciones.
Los comandos se pueden agrupar entre llaves, {expr_1; ...; expr_m}, en cuyo caso el valor del grupo es el
resultado de la última expresión del grupo evaluado. Dado que tal grupo es también una expresión, puede, por
ejemplo, incluirse entre paréntesis y usarse como parte de una expresión aún mayor, y así sucesivamente.
9.2 Declaraciones de control

9.2.1 Ejecución condicional: declaraciones if
El lenguaje tiene disponible una construcción condicional de la forma > if

(expr_1) expr_2 else expr_3
donde expr 1 debe evaluarse como un único valor lógico y el resultado de la expresión completa es entonces
evidente.
Los operadores de “cortocircuito” && y || se utilizan a menudo como parte de la condición en una declaración
if. Considerando que & y | aplicar elementos a vectores, && y || se aplican a vectores de longitud uno y solo
evalúan su segundo argumento si es necesario.
Existe una versión vectorizada de la construcción if/else, la función ifelse. Tiene la forma ifelse(condición, a, b)
y devuelve un vector de la longitud de su argumento más largo, con elementos a[i] si la condición[i] es verdadera;
de lo contrario, b[i].
9.2.2 Ejecución repetitiva: bucles for, repetir y mientras También existe una construcción
de bucle for que tiene la forma
> para (nombre en expr_1) expr_2 donde
nombre es la variable del bucle. expr 1 es una expresión vectorial (a menudo una secuencia como 1:20) y expr 2
es a menudo una expresión agrupada con sus subexpresiones escritas en términos del nombre ficticio. expr 2 se
evalúa repetidamente a medida que el nombre varía entre los valores en el resultado vectorial de expr 1.
Como ejemplo, supongamos que ind es un vector de indicadores de clase y deseamos producir gráficas
1
separadas de y versus x dentro de las clases. Una posibilidad aquí es usar coplot(), que producirá una serie de
gráficos correspondientes a cada nivel del factor. Otra forma de hacer esto, ahora colocando todos los gráficos en
una sola pantalla, es la siguiente: > xc < split(x,
ind) > yc < split(y, ind) > for
(i in 1:length(yc) ) { trama(xc[[i]],
yc[[i]]) abline(lsfit(xc[[i]], yc[[i]]))
}
(Tenga en cuenta la función split() que produce una lista de vectores obtenidos al dividir un vector más grande
según las clases especificadas por un factor. Esta es una función útil, utilizada principalmente en relación con
diagramas de caja. Consulte la función de ayuda para obtener más detalles).
1
que se discutirá más adelante, o use xyplot del paquete lattice (https://CRAN.Rproject.org/package=lattice).
Capítulo 9: Agrupación, bucles y ejecución condicional. 41
Advertencia: los bucles for() se utilizan en código R con mucha menos frecuencia que en lenguajes compilados.
Es probable que el código que adopta una vista de "objeto completo" sea más claro y más rápido en R.
Otras instalaciones de bucle incluyen el
> repetir la
declaración expr y el
> mientras (condición) expr

declaración.
La declaración break se puede utilizar para finalizar cualquier bucle, posiblemente de forma anormal. Esta es la única
manera de terminar los bucles repetidos.
La siguiente declaración se puede utilizar para interrumpir un ciclo en particular y pasar al "siguiente".
Las declaraciones de control se utilizan con mayor frecuencia en relación con funciones que se analizan en
Capítulo 10 [Escribir tus propias funciones], página 42, y donde surgirán más ejemplos.
Capítulo 10: Escribir tus propias funciones 42
10 Escribiendo tus propias funciones

Como hemos visto informalmente a lo largo del camino, el lenguaje R permite al usuario crear objetos de modo función.
Estas son verdaderas funciones de R que se almacenan en una forma interna especial y pueden usarse en otras
expresiones, etc. En el proceso, el lenguaje gana enormemente en poder, conveniencia y elegancia, y aprender a escribir
funciones útiles es una de las principales formas de hacer que el uso de R sea cómodo y productivo.
Se debe enfatizar que la mayoría de las funciones proporcionadas como parte del sistema R, como mean(), var(),
postscript(), etc., están escritas en R y, por lo tanto, no difieren materialmente de las funciones escritas por el usuario.
Una función se define mediante una asignación de la forma
> nombre < función (arg_1, arg_2, ...) expresión

La expresión es una expresión R (normalmente una expresión agrupada), que utiliza los argumentos, arg i, para calcular
un valor.
- El valor de la expresión es el valor devuelto por la función.
Una llamada a la función normalmente toma la forma nombre(expr_1, expr_2, ...) y puede
ocurren en cualquier lugar donde una llamada a función sea legítima.
10.1 Ejemplos sencillos

Como primer ejemplo, considere una función para calcular el estadístico t de dos muestras, que muestra "todos los
pasos". Este es un ejemplo artificial, por supuesto, ya que existen otras formas más sencillas de lograr el mismo fin.
La función se define de la siguiente manera:
> dosam < función(y1, y2) { n1 < longitud(y1);

n2 < longitud(y2) yb1 < media(y1); yb2 < media(y2)
s1 < var(y1); s2 < var(y2) s < ((n11)*s1 +
(n21)*s2)/(n1+n22) tst < (yb1 yb2)/sqrt(s*(1 /
n1 + 1/n2))
tst
}
Con esta función definida, podría realizar dos pruebas t de muestra utilizando una llamada como
> tstat < twosam(datos$masculino, datos$femenino); tstat
Como segundo ejemplo, consideremos una función para emular directamente el comando de barra invertida de
Matlab, que devuelve los coeficientes de la proyección ortogonal del vector y sobre el espacio columna de la matriz, X.
(Esto se denomina normalmente estimación de mínimos cuadrados de la coeficientes de regresión.) Esto normalmente
se haría con la función qr(); sin embargo, a veces esto es un poco complicado de usar directamente y vale la pena tener
una función simple como la siguiente para usarlo de forma segura.
Así, dado un vector y por 1 y una matriz X n por p, entonces X y se define como (XT X) −XT y, donde (XT X) − es
una inversa generalizada de XX. > bslash < función(X, y)
{ X < qr(X) qr.coef(X, y)
Una vez creado este objeto, se puede utilizar en declaraciones como

> regcoeff < bslash(Xmat, yvar)
etcétera.
La función clásica de R lsfit() hace este trabajo bastante bien y más1 . A su vez, utiliza las funciones qr() y qr.coef() de la
forma ligeramente contraintuitiva anterior para realizar esta parte del cálculo. Por lo tanto, probablemente tenga algún valor
tener solo esta parte aislada en una función fácil de usar si se va a utilizar con frecuencia. Si es así, es posible que deseemos
convertirlo en un operador binario matricial para un uso aún más conveniente.
10.2 Definición de nuevos operadores binarios

Si le hubiéramos dado a la función bslash() un nombre diferente, concretamente uno de la forma
%cualquier cosa%
podría haberse utilizado como operador binario en expresiones en lugar de en forma de función. Supongamos, por ejemplo,
que elegimos ! por el carácter interno. La definición de la función entonces comenzaría como
> "%!%" < función(X, y) { ... }
(Tenga en cuenta el uso de comillas). La función podría usarse entonces como X %!% y. (El símbolo de barra invertida en sí no
es una elección conveniente ya que presenta problemas especiales en este contexto).
El operador de multiplicación de matrices, %*%, y el operador de matriz de producto externo %o% son otros ejemplos de
operadores binarios definidos de esta manera.
10.3 Argumentos con nombre y valores predeterminados Como se
señaló por primera vez en la Sección 2.3 [Generación de secuencias regulares], página 8, si los argumentos para las funciones
llamadas se dan en la forma “nombre=objeto”, se pueden dar en cualquier orden. Además, la secuencia de argumentos puede
comenzar en forma posicional sin nombre y especificar argumentos con nombre después de los argumentos posicionales.
Por lo tanto, si hay una función fun1 definida por
> fun1 < function(datos, data.frame, gráfico, límite) { [cuerpo de la función omitido]
entonces la función se puede invocar de varias maneras, por ejemplo
> ans < fun1(d, df, VERDADERO, 20) > ans <
fun1(d, df, gráfico=VERDADERO, límite=20) > ans < fun1(datos=d,
límite=20, gráfico=VERDADERO, marco.datos=df)
son todos equivalentes.
En muchos casos, a los argumentos se les pueden dar valores predeterminados comúnmente apropiados, en cuyo caso
pueden omitirse por completo de la llamada cuando los valores predeterminados sean apropiados. Por ejemplo, si fun1 se
definiera como
> fun1 < función (datos, marco.de.datos, gráfico=VERDADERO, límite=20) {...}

se podría llamar como
> respuesta < fun1(d, df)
que ahora es equivalente a los tres casos anteriores, o como
> ans < fun1(d, df, límite=10)
que cambia uno de los valores predeterminados.
Es importante tener en cuenta que los valores predeterminados pueden ser expresiones arbitrarias, incluso involucrando
otros argumentos para la misma función; no están restringidos a ser constantes como en nuestro ejemplo simple aquí.
1
Consulte también los métodos descritos en el Capítulo 11 [Modelos estadísticos en R], página 51.
10.4 El argumento '...'

Otro requisito frecuente es permitir que una función pase la configuración de los argumentos a otra.
Por ejemplo, muchas funciones gráficas utilizan la función par() y funciones como plot() permiten al usuario pasar parámetros
gráficos a par() para controlar la salida gráfica. (Consulte la Sección 12.4.1 [La función par()], página 68, para obtener más
detalles sobre la función par()). Esto se puede hacer incluyendo un argumento adicional, literalmente '...', de la función, que
entonces podrá transmitirse. A continuación se ofrece un ejemplo general.
fun1 < function(data, data.frame, graph=TRUE, limit=20, ...) { [declaraciones omitidas] if (graph)
par(pch="*", ...) [más
omisiones]
Con menos frecuencia, una función necesitará hacer referencia a componentes de '...". La expresión list(...) evalúa
todos esos argumentos y los devuelve en una lista con nombre, mientras que ..1, ..2, etc. los evalúa uno a la vez, con '..n'
devolviendo el enésimo no coincidente argumento.
10.5 Asignaciones dentro de funciones

Tenga en cuenta que cualquier asignación ordinaria realizada dentro de la función es local y temporal y se pierde después
de salir de la función. Por tanto, la asignación X < qr(X) no afecta el valor del argumento en el programa que llama.
Para comprender completamente las reglas que rigen el alcance de las tareas de R, el lector debe estar familiarizado
con la noción de marco de evaluación. Este es un tema algo avanzado, aunque no difícil, y no se trata más aquí.
Si se pretenden asignaciones globales y permanentes dentro de una función, entonces se puede utilizar el operador
de “superasignación”, << o la función asignar(). Consulte el documento de ayuda para obtener más detalles. Los usuarios
de SPlus deben tener en cuenta que << tiene una semántica diferente en R. Esto se analiza con más detalle en la
Sección 10.7 [Alcance], página 46.
10.6 Ejemplos más avanzados

10.6.1 Factores de eficiencia en diseños de bloques
Como ejemplo de función más completo, aunque un poco peatonal, considere encontrar los factores de eficiencia para un
diseño de bloque. (Algunos aspectos de este problema ya se han discutido en la Sección 5.3 [Matrices de índice], página
19.)
Un diseño de bloques se define por dos factores, digamos bloques (niveles b) y variedades (niveles v). Si R y K son las
replicaciones v por v y b por b y las matrices de tamaño de bloque, respectivamente, y N es la matriz de incidencia b por v,
entonces los factores de eficiencia se definen como los valores propios de la matriz.
E = Iv − R −1/2N T K−1NR−1/2 = Iv − A TA,
donde A = K−1/2NR−1/2 . A continuación se proporciona una forma de escribir la función. >

bdeff < función(bloques, variedades) { bloques <
as.factor(bloques) b < # movimiento de seguridad menor
longitud(niveles(bloques)) variedades <

as.factor(variedades) v < longitud(niveles(variedades)) # movimiento de seguridad menor
K < as.vector(tabla(bloques)) # eliminar atributo tenue

R < as.vector(tabla(variedades)) # eliminar atributo tenue
N < tabla(bloques, variedades)

A < 1/sqrt(K) * N * rep(1/sqrt(R), rep(b, v)) sv < svd(A) list(eff=1
sv$d^2,
blockcv=sv $u, variedadcv=sv$v)
}
Numéricamente es ligeramente mejor trabajar con la descomposición de valores singulares en esta ocasión que
con las rutinas de valores propios.
El resultado de la función es una lista que proporciona no sólo los factores de eficiencia como primer componente,
sino también los contrastes canónicos de bloque y variedad, ya que a veces estos proporcionan información cualitativa
útil adicional.
10.6.2 Eliminación de todos los nombres en una matriz impresa Para fines
de impresión con matrices o matrices grandes, suele ser útil imprimirlas en forma de bloque cerrado sin los nombres
o números de la matriz. Eliminar el atributo dimnames no logrará este efecto, sino que a la matriz se le debe dar un
atributo dimnames que consta de cadenas vacías.
Por ejemplo para imprimir una matriz, X
> temp < X >
dimnames(temp) < list(rep("", nrow(X)), rep("", ncol(X))) > temp; habitación (temperatura)
Esto se puede hacer mucho más convenientemente usando una función, no.dimnames(), que se muestra a
continuación, como un "envoltura" para lograr el mismo resultado. También ilustra cómo algunas funciones de usuario
efectivas y útiles pueden ser bastante breves.
no.dimnames < función (a) {
## Elimine todos los nombres de dimensiones de una matriz para una impresión
compacta. d <
lista() l < 0
for(i en dim(a)) { d[[l < l +
1]] < rep("", i)
}
nombres tenues(a) < d
a
}
Con esta función definida, se puede imprimir una matriz en formato cercano usando
> no.dimnames(X)
Esto es particularmente útil para matrices de enteros grandes, donde los patrones son el interés real en lugar de
los valores.
10.6.3 Integración numérica recursiva Las funciones pueden ser

recursivas y pueden definir funciones dentro de sí mismas. Sin embargo, tenga en cuenta que dichas funciones, o
incluso variables, no son heredadas por funciones llamadas en marcos de evaluación superiores como lo serían si
estuvieran en la ruta de búsqueda.
El siguiente ejemplo muestra una forma ingenua de realizar una integración numérica unidimensional.
El integrando se evalúa en los puntos finales del rango y en el medio. Si la respuesta de la regla del trapecio de un
panel es lo suficientemente cercana a la de los dos paneles, entonces este último se devuelve como valor.
De lo contrario, el mismo proceso se aplica recursivamente a cada panel. El resultado es un proceso de integración
adaptativa que concentra las evaluaciones de funciones en regiones donde el integrando está más alejado de ser
lineal. Sin embargo, hay una gran sobrecarga y la función sólo es competitiva con otros algoritmos cuando el
integrando es fluido y muy difícil de evaluar.
El ejemplo también se presenta en parte como un pequeño rompecabezas de programación en R.
área < función(f, a, b, eps = 1.0e06, lim = 10) {

fun1 < function(f, a, b, fa, fb, a0, eps, lim, fun) { ## la función 'fun1' solo es
visible dentro del 'área' d < (a + b)/2 h < (b a)/4 fd
< f(d) a1 < h * (fa
+ fd) a2 < h * (fd +
fb) if(abs(a0
a1 a2) < eps || lim = = 0)
return(a1 + a2) else
{ return(fun(f, a, d, fa, fd, a1, eps, lim 1, fun) + fun(f, d,
b, fd, fb, a2, eps, lim
1,
divertido))
}
}
fa < f(a) fb <
f(b) a0 < ((fa
+ fb) * (b a))/2 fun1(f, a, b, fa, fb, a0,
eps, lim , divertido1)
}
10.7 Alcance
La discusión en esta sección es algo más técnica que en otras partes de este documento.
Sin embargo, detalla una de las principales diferencias entre SPlus y R.
Los símbolos que aparecen en el cuerpo de una función se pueden dividir en tres clases; parámetros formales,
variables locales y variables libres. Los parámetros formales de una función son los que aparecen en la lista de
argumentos de la función. Sus valores están determinados por el proceso de vincular los argumentos de la función
real a los parámetros formales. Las variables locales son aquellas cuyos valores están determinados por la
evaluación de expresiones en el cuerpo de las funciones. Las variables que no son parámetros formales o
variables locales se denominan variables libres. Las variables libres se convierten en variables locales si se les
asignan. Considere la siguiente definición de función.
f < función(x) { y < 2*x
imprimir(x)
imprimir(y)
imprimir(z)
En esta función, x es un parámetro formal, y es una variable local yz es una variable libre.
En R, los enlaces de variables libres se resuelven mirando primero el entorno en el que se encuentra la variable.
Se creó la función. A esto se le llama alcance léxico. Primero definimos una función llamada cubo.
cubo < función (n) {
cuadrado < función()
n*nn*cuadrado()
}
La variable n en la función sq no es un argumento para esa función. Por lo tanto, es una variable libre y se
deben utilizar reglas de alcance para determinar el valor que se le asociará. Bajo alcance estático (SPlus), el valor
es el asociado con una variable global llamada n.
Bajo el alcance léxico (R), es el parámetro del cubo de funciones, ya que es el enlace activo para la variable n en
el momento en que se definió la función sq. La diferencia entre evaluación
en R y la evaluación en SPlus es que SPlus busca una variable global llamada n mientras que R primero busca
una variable llamada n en el entorno creado cuando se invocó el cubo.
## primera evaluación en S
S> cubo(2)
Error en sq(): Objeto "n" no encontrado
objeto de dumping
S>n< 3
S> cube(2)
[1] 18
## entonces la misma función evaluada en R
R> cubo(2)
[1] 8
El alcance léxico también se puede utilizar para dar a funciones un estado mutable. En el siguiente ejemplo
mostramos cómo se puede utilizar R para imitar una cuenta bancaria. Una cuenta bancaria que funcione debe
tener un saldo o total, una función para realizar retiros, una función para realizar depósitos y una función para
indicar el saldo actual. Logramos esto creando las tres funciones dentro de la cuenta y luego devolviendo una lista
que las contiene. Cuando se invoca la cuenta, toma un argumento numérico total y devuelve una lista que contiene
las tres funciones. Debido a que estas funciones están definidas en un entorno que contiene total, tendrán acceso
a su valor.
El operador de asignación especial, <<, se utiliza para cambiar el valor asociado con el total.
Este operador busca en entornos adjuntos un entorno que contenga el símbolo total y cuando encuentra dicho
entorno reemplaza el valor, en ese entorno, con el valor del lado derecho. Si se alcanza el entorno global o de
nivel superior sin encontrar el símbolo total, entonces esa variable se crea y se asigna allí. Para la mayoría de los
usuarios, << crea una variable global y le asigna el valor del lado derecho2 . Sólo cuando se haya utilizado << en
una función que se devolvió como valor de otra función se producirá el comportamiento especial descrito aquí.
cuenta abierta < función (total) {
list( depósito = función(monto) { if(monto

<= 0) stop("¡Los
depósitos deben ser positivos!\n")
total << total + monto cat(monto,
"depositado. Su saldo es", total, "\n\n") }, retirar = función(monto) { if(monto > total)
stop("¡No tienes tanto dinero!\n") total << total cantidad

cat(monto, "retirado. Tu saldo es",
total, "\n\n") }, saldo = función( ) { cat("Su saldo es", total, "\n\n")
}
)
}
ross < cuenta abierta (100)
2
En cierto sentido, esto imita el comportamiento en SPlus ya que en SPlus este operador siempre crea o asigna
una variable global.
robert < cuenta abierta (200)
ross$retirar(30)
ross$saldo()
robert$saldo()
ross$depósito(50)
ross$saldo()
ross$retirar(500)
10.8 Personalización del entorno

Los usuarios pueden personalizar su entorno de varias maneras diferentes. Hay un archivo de inicialización del sitio y cada
directorio puede tener su propio archivo de inicialización especial. Finalmente, se pueden utilizar las funciones
especiales .First y .Last.
La ubicación del archivo de inicialización del sitio se toma del valor de la variable de entorno R_PROFILE. Si esa
variable no está configurada, se utiliza el archivo Rprofile.site en el subdirectorio de inicio de R, etc.
Este archivo debe contener los comandos que desea ejecutar cada vez que se inicia R en su sistema. Un segundo archivo
de perfil personal llamado .Rprofile3 se puede colocar en cualquier directorio. Si se invoca R en ese directorio, se obtendrá
ese archivo. Este archivo brinda a los usuarios individuales control sobre su espacio de trabajo y permite diferentes
procedimientos de inicio en diferentes directorios de trabajo.
Si no se encuentra ningún archivo .Rprofile en el directorio de inicio, R busca un archivo .Rprofile en el directorio de inicio
del usuario y lo usa (si existe). Si se establece la variable de entorno R_PROFILE_USER, se utiliza el archivo al que apunta
en lugar de los archivos .Rprofile.
Cualquier función denominada .First() en cualquiera de los dos archivos de perfil o en la imagen .RData tiene un estado
especial. Se realiza automáticamente al comienzo de una sesión de R y puede usarse para inicializar el entorno. Por
ejemplo, la definición del siguiente ejemplo modifica el mensaje a $ y configura otras cosas útiles que luego se pueden dar
por sentado en el resto de la sesión.
Así, la secuencia en la que se ejecutan los archivos es, Rprofile.site, el perfil de usuario, .RData
y luego .Primero(). Una definición en archivos posteriores enmascarará las definiciones de archivos anteriores.
> .Primera < función() {

options(prompt="$ ", continue="+\t") # $ es el mensaje options(digits=5, length=999)
# números personalizados e impresión x11() # para gráficos par(pch = "+") # trazar la fuente del
carácter(file.path(Sys.getenv("HOME"), "R", "mystuff.R"))
# mis funciones personales #

biblioteca (MASA) adjuntar un paquete
}
De manera similar, una función .Last(), si está definida, se ejecuta (normalmente) al final de la sesión.
A continuación se ofrece un ejemplo.
> .Último < función() { gráficos.off()

# una pequeña medida de seguridad.
cat(pegar(fecha(),"\nAdios\n")) # ¿Es hora de almorzar?
}
3
Por eso está oculto en UNIX.
10.9 Clases, funciones genéricas y orientación a objetos

La clase de un objeto determina cómo será tratado por las llamadas funciones genéricas.
Dicho al revés, una función genérica realiza una tarea o acción sobre sus argumentos específicos de la clase del
argumento en sí. Si el argumento carece de algún atributo de clase, o tiene una clase que no es atendida
específicamente por la función genérica en cuestión, siempre se proporciona una acción predeterminada.
Un ejemplo aclara las cosas. El mecanismo de clases ofrece al usuario la posibilidad de diseñar y escribir
funciones genéricas para propósitos especiales. Entre las otras funciones genéricas se encuentran plot() para
mostrar objetos gráficamente, resumen() para resumir análisis de varios tipos y anova() para comparar modelos
estadísticos.
La cantidad de funciones genéricas que pueden tratar una clase de una manera específica puede ser bastante grande.
Por ejemplo, las funciones que pueden acomodar en algunos objetos de la clase "data.frame" incluyen
[ [[< [< como.matriz

significa cualquier resumen de la trama
Se puede obtener una lista actualmente completa utilizando la función métodos():

> métodos(clase="datos.marco")
Por el contrario, el número de clases que puede manejar una función genérica también puede ser bastante grande.
Por ejemplo, la función plot() tiene un método predeterminado y variantes para objetos de las clases "data.frame",
"density", "factor" y más. Se puede obtener nuevamente una lista completa usando la función métodos():
> métodos(trama)
Para muchas funciones genéricas, el cuerpo de la función es bastante corto, por ejemplo
> coef
función (objeto, ...)
UsarMétodo("coef")
La presencia de UseMethod indica que se trata de una función genérica. Para ver qué métodos están disponibles
podemos usar métodos()
> métodos(coef) [1]
coef.aov* [5] coef.arima* coef.predeterminado* coef.listade*
coef.nls* coef.summary.nls*
Las funciones no visibles están marcadas con un asterisco
En este ejemplo hay seis métodos, ninguno de los cuales se puede ver al escribir su nombre. Podemos leerlos
mediante >
getAnywhere("coef.aov")
Se encontró un único objeto que coincidía con 'coef.aov'. Se
encontró en los siguientes lugares registrados como
método S3 para coef del espacio de nombres stats namespace:stats con
valor
función (objeto, ...) {
z < objeto$coef z[!

is.na(z)]
}
> getS3method("coef", "aov") función

(objeto, ...) {
z < objeto$coef z[!

is.na(z)]
}
Una función llamada gen.cl será invocada por el gen genérico para la clase cl, así que no nombre
funciones en este estilo a menos que estén destinadas a ser métodos.
Se remite al lector a la Definición del lenguaje R para obtener una discusión más completa de este mecanismo.
Capítulo 11: Modelos estadísticos en R 51
11 modelos estadísticos en R
Esta sección supone que el lector tiene cierta familiaridad con la metodología estadística, en particular
con análisis de regresión y análisis de varianza. Más adelante hacemos algunas algo más ambiciosas.
presunciones, es decir, que se sabe algo sobre los modelos lineales generalizados y los modelos no lineales.
regresión.
Los requisitos para ajustar modelos estadísticos están suficientemente bien definidos para que sea posible
construir herramientas generales que se apliquen en un amplio espectro de problemas.
R proporciona un conjunto entrelazado de funciones que simplifican mucho el ajuste de modelos estadísticos.
Como mencionamos en la introducción, el resultado básico es mínimo y es necesario solicitar el
detalles llamando a funciones extractoras.
11.1 Definición de modelos estadísticos; fórmulas

La plantilla para un modelo estadístico es un modelo de regresión lineal con independientes y homocedásticos.
errores
pag
hacer = βjxij + ei , es NO (0, σ2 ), yo = 1, . . . , norte
j=0
En términos matriciales esto se escribiría
y = Xβ + e
donde y es el vector de respuesta, X es la matriz del modelo o matriz de diseño y tiene columnas
x0, x1, . . . , xp, las variables determinantes. Muy a menudo x0 será una columna de unos que definen un
término de intersección.
Ejemplos
Antes de dar una especificación formal, algunos ejemplos pueden ser útiles para aclarar el panorama.
Supongamos y, x, x0, x1, x2, . . . son variables numéricas, X es una matriz y A, B, C, . . . son factores.
Las siguientes fórmulas en el lado izquierdo especifican modelos estadísticos como se describe a la derecha.
~
y X
y ~ 1 + x Ambos implican el mismo modelo de regresión lineal simple de y sobre x. El primero tiene un
término de intercepción implícito, y el segundo explícito.
y ~0+x
y ~1+x
~
y x 1 Regresión lineal simple de y sobre x a través del origen (es decir, sin intersección
término).
iniciar sesión(y) ~ x1 + x2
Regresión múltiple de la variable transformada, log(y), en x1 y x2 (con una
término de intersección implícito).
y ~ poli(x,2)
y ~ 1 + x + I(x^2)
Regresión polinómica de y sobre x de grado 2. La primera forma utiliza polinomios ortogonales y la segunda utiliza
potencias explícitas como base.
y ~ X + poli(x,2)
Regresión múltiple y con matriz modelo compuesta por la matriz X y
términos polinomiales en x de grado 2.
y ~ Un Análisis de clasificación única del modelo de varianza de y, con clases determinadas por A.
y ~ A + x Análisis de clasificación única del modelo de covarianza de y, con clases determinadas por
A, y con covariable x.
y ~A*B
y ~ A + B + A:B
y ~ B %en% A
y ~ A/B Modelo no aditivo de dos factores de y en A y B. Los dos primeros especifican lo mismo
clasificación cruzada y los dos segundos especifican la misma clasificación anidada. En
En términos abstractos, los cuatro especifican el mismo subespacio modelo.
y ~(A+B+C)^2
y ~ A*B*C A:B:C
Experimento de tres factores pero con un modelo que contiene efectos principales y dos factores.
interacciones únicamente. Ambas fórmulas especifican el mismo modelo.
y ~A*x
y ~ A/x
y ~ A/(1 + x) 1
Separe los modelos de regresión lineal simple de y sobre x dentro de los niveles de A, con
diferentes codificaciones. La última forma produce estimaciones explícitas de tantos diferentes
intercepta y tiene pendientes ya que hay niveles en A.
y ~ A*B + Error(C)
Un experimento con dos factores de tratamiento, A y B, y estratos de error determinados
por el factor C. Por ejemplo, un experimento de parcela dividida, con parcelas completas (y por lo tanto también
subtramas), determinada por el factor C.
El operador ~ se utiliza para definir una fórmula modelo en R. La forma, para un lineal ordinario
modelo, es
respuesta ~ en_1 término_1 en_2 término_2 en_3 término_3 ...

dónde
La respuesta es un vector o matriz (o una expresión que se evalúa como un vector o matriz) que define el
variable(s) de respuesta.
en yo es un operador, ya sea + o , que implica la inclusión o exclusión de un término en el

modelo, (el primero es opcional).
término yo es cualquiera
• una expresión vectorial o matricial, o 1,
• un factor, o
• una expresión de fórmula que consta de factores, vectores o matrices conectados por
operadores de fórmula.
En todos los casos, cada término define una colección de columnas que se agregarán o agregarán.
eliminado de la matriz del modelo. Un 1 representa una columna de intersección y es por
valor predeterminado incluido en la matriz del modelo a menos que se elimine explícitamente.
Los operadores de fórmula son similares en efecto a la notación de Wilkinson y Rogers utilizada por
programas como Glim y Genstat. Un cambio inevitable es que el operador '.' se convierte en ':'
ya que el punto es un carácter de nombre válido en R.
La notación se resume a continuación (basada en Chambers & Hastie, 1992, p.29):
Y~M Y se modela como M.
M_1 + M_2 Incluye M 1 y M 2.

M_1 M_2 Incluye M 1 omitiendo los términos de M 2.
M_1 : M_2 El producto tensorial de M 1 y M 2. Si ambos términos son factores, entonces las “subclases”
factor.
M_1 %en% M_2

Similar a M_1:M_2, pero con una codificación diferente.
M_1 * M_2 M_1 + M_2 + M_1:M_2.
M_1 / M_2 M_1 + M_2 %en% M_1.
m^n Todos los términos en M junto con las “interacciones” hasta el orden n
SOY) Aísle M. Dentro de M, todos los operadores tienen su significado aritmético normal y ese término aparece en
la matriz del modelo.
Tenga en cuenta que dentro de los paréntesis que normalmente encierran los argumentos de las funciones, todos los
operadores tienen su significado aritmético normal. La función I() es una función de identidad que se utiliza para permitir que
los términos de las fórmulas modelo se definan mediante operadores aritméticos.
Tenga en cuenta en particular que las fórmulas del modelo especifican las columnas de la matriz del modelo, estando
implícita la especificación de los parámetros. Este no es el caso en otros contextos, por ejemplo al especificar modelos no
lineales.
11.1.1 Contrastes
Necesitamos al menos alguna idea de cómo las fórmulas del modelo especifican las columnas de la matriz del modelo.
Esto es fácil si tenemos variables continuas, ya que cada una proporciona una columna de la matriz del modelo (y la
intersección proporcionará una columna de unos si se incluye en el modelo).
¿Qué pasa con un factor A de nivel k? La respuesta difiere para factores ordenados y desordenados. Para factores
. .,lo tanto, la
desordenados k − 1 se generan columnas para los indicadores del segundo, . késimos niveles del factor. (Por
parametrización implícita es contrastar la respuesta en cada nivel con la del primero). Para factores ordenados, las columnas
k − 1 son los polinomios ortogonales en 1, . . . , k, omitiendo el término constante.
Aunque la respuesta ya es complicada, no es toda la historia. En primer lugar, si se omite la intersección en un modelo
que contiene un término factorial, el primer término se codifica en k columnas que proporcionan los indicadores para todos
los niveles. En segundo lugar, todo el comportamiento se puede cambiar mediante la configuración de opciones de contrastes.
La configuración predeterminada en R es
opciones(contrastes = c("contr.tratamiento", "contr.poli"))
La razón principal para mencionar esto es que R y S tienen diferentes valores predeterminados para factores desordenados,
S usa los contrastes de Helmert. Entonces, si necesita comparar sus resultados con los de un libro de texto o documento
que utilizó SPlus, deberá configurar
opciones(contrastes = c("contr.helmert", "contr.poly"))
Esta es una diferencia deliberada, ya que se cree que los contrastes de tratamiento (el valor predeterminado de R) son más fáciles de
interpretar para los recién llegados.
Aún no hemos terminado, ya que se puede establecer el esquema de contraste a utilizar para cada término del
modelo usando las funciones contrastes y C.
Aún no hemos considerado los términos de interacción: estos generan los productos de las columnas.
introducidos para los términos que los componen.
Aunque los detalles son complicados, las fórmulas modelo en R normalmente generarán los modelos que un estadístico
experto esperaría, siempre que se preserve la marginalidad. Ajustar, por ejemplo, un modelo con una interacción pero no
con los efectos principales correspondientes conducirá en general a resultados sorprendentes y es sólo para expertos.
11.2 Modelos lineales

La función básica para ajustar múltiples modelos ordinarios es lm(), y una versión simplificada de la
la convocatoria es la siguiente:
> modelo.ajustado < lm(fórmula, datos = marco.datos)

Por ejemplo
> fm2 < lm(y ~ x1 + x2, datos = producción)
se ajustaría a un modelo de regresión múltiple de y en x1 y x2 (con término de intersección implícito).
El parámetro importante (pero técnicamente opcional) datos = producción especifica que cualquier
Las variables necesarias para construir el modelo deben provenir primero del marco de datos de producción.
Este es el caso independientemente de si la producción del marco de datos se ha adjuntado en la búsqueda.
camino o no.
11.3 Funciones genéricas para extraer información del modelo.

El valor de lm() es un objeto modelo ajustado; técnicamente una lista de resultados de la clase "lm". Información
información sobre el modelo ajustado se puede mostrar, extraer, trazar, etc. mediante el uso de
funciones que se orientan a objetos de clase "lm". Éstas incluyen
agregar1 fórmula de desviación predecir el paso
alias drop1 efectos residuos resumen
anova etiquetas kappa del tú
coef familia trama proyecto de impresión
A continuación se ofrece una breve descripción de los más utilizados.
anova(objeto_1, objeto_2)
Compare un submodelo con un modelo externo y produzca una tabla de análisis de varianza.
coef(objeto)
Extraiga el coeficiente de regresión (matriz).
Forma larga: coeficientes(objeto).
desviación (objeto)
Suma residual de cuadrados, ponderada si procede.
fórmula (objeto)
Extraiga la fórmula del modelo.
trama (objeto)
Produzca cuatro gráficos que muestren residuos, valores ajustados y algunos diagnósticos.
predecir (objeto, nuevos datos = datos.marco)

El marco de datos proporcionado debe tener variables especificadas con las mismas etiquetas que el
original. El valor es un vector o matriz de valores predichos correspondientes a la
determinar valores de variables en data.frame.
imprimir (objeto)
Imprima una versión concisa del objeto. Se utiliza con mayor frecuencia de forma implícita.
residuos (objeto)
Extraer la (matriz de) residuos, ponderados según corresponda.
Forma abreviada: residir (objeto).
paso (objeto)
Seleccione un modelo adecuado agregando o eliminando términos y preservando jerarquías. El
modelo con el valor más pequeño de AIC (criterio de información de Akaike) descubierto
en la búsqueda paso a paso se devuelve.
resumen (objeto)
Imprima un resumen completo de los resultados del análisis de regresión.
vcov(objeto)
Devuelve la matriz de varianzacovarianza de los parámetros principales de un objeto modelo ajustado.
11.4 Análisis de varianza y comparación de modelos.

La función de ajuste del modelo aov(formula, data=data.frame) opera en el nivel más simple de manera muy similar a
la función lm(), y la mayoría de las funciones genéricas enumeradas en la tabla de la Sección 11.3 [Funciones genéricas
para extraer el modelo información], página 54.
Cabe señalar que, además, aov() permite un análisis de modelos con múltiples estratos de error, como experimentos
de parcela dividida o diseños de bloques incompletos equilibrados con recuperación de información entre bloques. La
fórmula modelo
respuesta ~ media.fórmula + Error(estratos.fórmula)
especifica un experimento de múltiples estratos con estratos de error definidos por strata.formula. En el caso más
simple, strata.formula es simplemente un factor, cuando define un experimento de dos estratos, es decir, entre y dentro
de los niveles del factor.
Por ejemplo, con todos los factores variables determinantes, normalmente se utilizaría una fórmula modelo
como la de: > fm < aov(rendimiento ~ v + n*p*k + Error(granjas/bloques), datos=granja.datos)
describir un experimento con un modelo medio v + n*p*k y tres estratos de error, a saber, “entre granjas”, “dentro de
las granjas, entre bloques” y “dentro de bloques”.
11.4.1 Tablas ANOVA

Tenga en cuenta también que la tabla (o tablas) de análisis de varianza son para una secuencia de modelos ajustados.
Las sumas de cuadrados mostradas son la disminución en las sumas de cuadrados residuales resultantes de la
inclusión de ese término en el modelo en ese lugar de la secuencia. Por lo tanto, sólo para experimentos ortogonales
el orden de inclusión será intrascendente.
Para experimentos multiestrato, el procedimiento es primero proyectar la respuesta en los estratos de error,
nuevamente en secuencia, y ajustar el modelo medio a cada proyección. Para más detalles, véase Chambers y Hastie
(1992).
Una alternativa más flexible a la tabla ANOVA completa predeterminada es comparar dos o más modelos
directamente usando la función anova().
> anova(modelo.equipado.1, modelo.equipado.2, ...)
La pantalla es entonces una tabla ANOVA que muestra las diferencias entre los modelos ajustados cuando se
ajustan en secuencia. Por supuesto, los modelos ajustados que se comparan normalmente serían una secuencia
jerárquica. Esto no proporciona información diferente a la predeterminada, sino que la hace más fácil de comprender y
controlar.
11.5 Actualización de modelos instalados

La función update() es en gran medida una función de conveniencia que permite ajustar un modelo que difiere de uno
previamente ajustado, generalmente por solo unos pocos términos adicionales o eliminados. Su forma es
> nuevo.modelo < actualización(antiguo.modelo, nueva.fórmula)
En la nueva fórmula, el nombre especial que consta de un punto, '.', únicamente, se puede utilizar para representar
para “la parte correspondiente de la fórmula modelo anterior”. Por ejemplo,
> fm05 < lm(y ~ x1 + x2 + x3 + x4 + x5, datos = producción) > fm6 < actualización(fm05, .
~
+ x6) > smf6 < actualización(fm6, sqrt(.) .~ .)
ajustaría una regresión múltiple de cinco variables con variables (presumiblemente) de la producción del marco de
datos, ajustaría un modelo adicional que incluye una sexta variable regresora y ajustaría una variante en el modelo
donde a la respuesta se le aplicó una transformación de raíz cuadrada.
Tenga en cuenta especialmente que si el argumento data= se especifica en la llamada original a la función de
ajuste del modelo, esta información se pasa a través del objeto del modelo ajustado a update() y
sus aliados.
El nombre '.' También se puede utilizar en otros contextos, pero con un significado ligeramente diferente. Por
ejemplo
> fmfull < lm(y ~ . , datos = producción)
Se ajustaría a un modelo con respuesta y y variables regresoras para todas las demás variables en la producción del
marco de datos.
Otras funciones para explorar secuencias incrementales de modelos son add1(), drop1() y step(). Los nombres de
estos dan una buena pista sobre su propósito, pero para obtener detalles completos consulte la ayuda en línea.
11.6 Modelos lineales generalizados

El modelado lineal generalizado es un desarrollo de modelos lineales para acomodar tanto distribuciones de respuesta
no normales como transformaciones a linealidad de una manera limpia y sencilla. Un modelo lineal generalizado
puede describirse en términos de la siguiente secuencia de supuestos:
• Existe una respuesta, y, de las variables de interés y estímulo x1, x2, . . . , cuyos valores influyen en la distribución
de la respuesta.
• Las variables estímulo influyen en la distribución de y a través de una única función lineal, únicamente.
Esta función lineal se llama predictor lineal y generalmente se escribe
η = β1x1 + β2x2 + ∙ ∙ ∙ + βpxp,
por lo tanto, xi no tiene influencia en la distribución de y si y sólo si βi = 0. • La
distribución de y es de la forma
A
fY (y; µ, ) = exp - {yλ(μ) − γ (λ(μ))} + τ (y, )
donde es un parámetro de escala (posiblemente conocido) y es constante para todas las observaciones, A
representa un peso previo, que se supone conocido pero que posiblemente varía con las observaciones, y µ es
la media de y. Por tanto, se supone que la distribución de y está determinada por su media y posiblemente
también por un parámetro de escala.
• La media, µ, es una función invertible suave del predictor lineal:
µ = m(η), η = m−1 (µ) = (µ)
y esta función inversa, (), se llama función de enlace.
Estos supuestos son lo suficientemente flexibles como para abarcar una amplia clase de modelos útiles en la
práctica estadística, pero lo suficientemente estrictos como para permitir el desarrollo de una metodología unificada
de estimación e inferencia, al menos aproximadamente. Se remite al lector a cualquiera de las obras de referencia
actuales sobre el tema para obtener detalles completos, como McCullagh y Nelder (1989) o Dobson (1990).
11.6.1 Familias
La clase de modelos lineales generalizados manejados por las instalaciones proporcionadas en R incluye
distribuciones de respuesta gaussiana, binomial, poisson, gaussiana inversa y gamma y también modelos de cuasi
verosimilitud donde la distribución de respuesta no se especifica explícitamente. En el último caso, la función de
varianza debe especificarse como una función de la media, pero en otros casos esta función está implícita en la
distribución de respuesta.
Cada distribución de respuesta admite una variedad de funciones de enlace para conectar la media con la
predictor lineal. Los disponibles automáticamente se muestran en la siguiente tabla:
Apellido Funciones de enlace

binomio logit, probit, registro, identidad
gaussiano cloglog, registro, identidad
Gama inversa, inversa, log 1/mu^2,
inverso.gaussiano identidad, inversa, identidad de registro,
poisson registro, sqrt logit, probit,
cuasi cloglog, identidad, inversa, registro, 1/mu^2 , raíz cuadrada
La combinación de una distribución de respuesta, una función de enlace y varios otros datos necesarios para
llevar a cabo el ejercicio de modelado se denomina familia del modelo lineal generalizado.
11.6.2 La función glm() Dado que la

distribución de la respuesta depende de las variables del estímulo a través de una única función lineal, el mismo
mecanismo que se usó para los modelos lineales aún se puede usar para especificar la parte lineal de un modelo
generalizado. La familia tiene que especificarse de otra manera.
La función R para ajustar un modelo lineal generalizado es glm() que usa la forma
> modelo.ajustado < glm(fórmula, familia=familia.generador, datos=marco.datos)
La única novedad es el family.generator, que es el instrumento mediante el cual se describe la familia. Es el
nombre de una función que genera una lista de funciones y expresiones que juntas definen y controlan el modelo y
el proceso de estimación. Aunque esto pueda parecer un poco complicado a primera vista, su uso es bastante
sencillo.
Los nombres de los generadores de familia estándar suministrados se dan en “Apellido” en la tabla de la Sección
11.6.1 [Familias], página 57. Cuando hay una opción de enlaces, el nombre del enlace también se puede proporcionar
con el apellido, entre paréntesis como parámetro. En el caso de la cuasifamilia, la función de varianza también se
puede especificar de esta manera.
Algunos ejemplos aclaran el proceso.
La familia gaussiana
Una llamada como
> fm < glm(y ~ x1 + x2, familia = gaussiano, datos = ventas) logra el mismo
resultado que
> fm < lm(y ~ x1+x2, datos=ventas)

pero mucho menos eficiente. Tenga en cuenta que a la familia gaussiana no se le proporciona automáticamente una
opción de enlaces, por lo que no se permite ningún parámetro. Si un problema requiere una familia gaussiana con
un vínculo no estándar, esto generalmente se puede lograr a través de la cuasi familia, como veremos más adelante.
La familia binomial Consideremos
un pequeño ejemplo artificial de Silvey (1970).

En la isla de Kalythos, en el Egeo, los habitantes masculinos padecen una enfermedad ocular congénita, cuyos
efectos se acentúan con la edad. Se realizaron pruebas de ceguera a muestras de varones isleños de distintas edades
y se registraron los resultados. Los datos se muestran a continuación:
Edad: 20 35 45 55 70 50 50 50 50
No. examinados: 50 6 17 26 37 44
No. ciegos:
El problema que planteamos es ajustar los modelos logístico y probit a estos datos y estimar para cada modelo la
LD50, es decir, la edad a la que la probabilidad de ceguera para un habitante masculino es del 50%.
Si y es el número de ciegos a la edad x y n el número evaluado, ambos modelos tienen la forma
y B(n, F(β0 + β1x))
donde para el caso probit, F(z) = Φ(z) es la función de distribución normal estándar, y en el caso logit (el valor
predeterminado), F(z) = e z/(1 + e z ) . En ambos casos la LD50 es
LD50 = −β0/β1
es decir, el punto en el que el argumento de la función de distribución es cero.

El primer paso es configurar los datos como un marco de datos.
> kalythos < data.frame(x = c(20,35,45,55,70), n = rep(50,5), y = c(6,17,26,37,44))
Para ajustar un modelo binomial usando glm() hay tres posibilidades para la respuesta: • Si la
respuesta es un vector, se supone que contiene datos binarios y, por lo tanto, debe ser un vector 0/1. • Si la
respuesta es una matriz de dos columnas, se supone que la primera columna contiene el número
de éxitos para la prueba y el segundo tiene el número de fracasos.
• Si la respuesta es un factor, su primer nivel se toma como fracaso (0) y todos los demás niveles como 'éxito'
(1).
Aquí necesitamos la segunda de estas convenciones, por lo que agregamos una matriz a nuestro marco
de datos: > kalythos$Ymat < cbind(kalythos$y, kalythos$n kalythos$y)
Para adaptarse a los modelos que utilizamos.
> fmp < glm(Ymat ~ x, familia = binomial(link=probit), datos = kalythos) > fml < glm(Ymat ~ x, familia =
binomial, datos = kalythos)
Dado que el enlace logit es el predeterminado, el parámetro puede omitirse en la segunda llamada. Para ver los
resultados de cada ajuste podríamos usar
> resumen(fmp) >

resumen(fml)
Ambos modelos encajan (demasiado) bien. Para encontrar la estimación de LD50 podemos usar una función
simple: > ld50 < function(b) b[1]/b[2] > ldp <
ld50(coef(fmp)); ldl < ld50(coef(fml)); c(ldp, ldl)
Las estimaciones reales a partir de estos datos son 43.663 años y 43.601 años respectivamente.
modelos venenosos
Con la familia Poisson, el vínculo predeterminado es el registro y, en la práctica, el uso principal de esta familia es
ajustar modelos loglineales sustitutos de Poisson a datos de frecuencia, cuya distribución real suele ser multinomial.
Este es un tema amplio e importante que no discutiremos más aquí. Incluso forma una parte importante del uso de
modelos generalizados no gaussianos en general.
Ocasionalmente, en la práctica surgen datos genuinamente de Poisson y en el pasado a menudo se analizaban
como datos gaussianos después de una transformación logarítmica o de raíz cuadrada. Como alternativa elegante a
este último, se puede ajustar un modelo lineal generalizado de Poisson como en el siguiente ejemplo:
> fmod < glm(y ~ A + B + x, familia = poisson(enlace=sqrt), datos = gusano.counts)
Modelos de cuasi verosimilitud

Para todas las familias la varianza de la respuesta dependerá de la media y tendrá como multiplicador el parámetro de
escala. La forma de dependencia de la varianza de la media es una característica de la distribución de respuesta; por
ejemplo para la distribución de Poisson Var[y] = µ.
Para la estimación e inferencia de cuasi verosimilitud no se especifica la distribución de respuesta precisa, sino sólo
una función de vínculo y la forma de la función de varianza, ya que depende de la media. Dado que la estimación de
cuasi verosimilitud utiliza técnicas formalmente idénticas a las de la distribución gaussiana, esta familia proporciona una
forma de ajustar modelos gaussianos con funciones de enlace o funciones de varianza no estándar, dicho sea de paso.
Por ejemplo, considere ajustar la regresión no lineal
θ1z1
y= +y
z2 − θ2
que puede escribirse alternativamente como
1
y= +e
β1x1 + β2x2
donde x1 = z2/z1, x2 = −1/z1, β1 = 1/θ1 y β2 = θ2/θ1. Suponiendo que se establezca un marco de datos adecuado,
podríamos ajustar esta regresión no lineal como > nlfit < glm(y
~ x1 + x2 1, familia = cuasi(enlace=inverso,
varianza=constante), datos = bioquímica)
Se remite al lector al manual y al documento de ayuda para obtener más información, según sea necesario.
11.7 Modelos de mínimos cuadrados no lineales y de máxima verosimilitud Ciertas formas de modelos no lineales
pueden ajustarse mediante modelos lineales generalizados (glm()). Pero en la mayoría de los casos tenemos que
abordar el problema de ajuste de curvas no lineales como uno de optimización no lineal. Las rutinas de optimización no
lineal de R son optim(), nlm() y nlminb(), que proporcionan la funcionalidad (y más) de ms() y nlminb() de SPlus.
Buscamos los valores de los parámetros que minimicen algún índice de falta de ajuste, y lo hacen probando varios
valores de parámetros de forma iterativa. A diferencia de la regresión lineal, por ejemplo, no hay garantía de que el
procedimiento converja en estimaciones satisfactorias. Todos los métodos requieren conjeturas iniciales sobre qué
valores de parámetros probar, y la convergencia puede depender críticamente de la calidad de los valores iniciales.
11.7.1 Mínimos cuadrados Una
forma de ajustar un modelo no lineal es minimizando la suma de los errores cuadrados (SSE) o residuos. Este método
tiene sentido si los errores observados podrían haber surgido de una distribución normal.
A continuación se muestra un ejemplo de Bates y Watts (1988), página 51. Los datos son:
> x < c(0.02, 0.02, 0.06, 0.06, 0.11, 0.11, 0.22, 0.22, 0.56, 0.56, 1.10, 1.10) > y < c(76, 47, 97, 107,
123, 139, 159,
152, 191, 201, 207, 200)
El criterio de ajuste a minimizar es:
> fn < función(p) suma((y (p[1] * x)/(p[2] + x))^2)

Para realizar el ajuste necesitamos estimaciones iniciales de los parámetros. Una forma de encontrar valores iniciales
sensatos es trazar los datos, adivinar algunos valores de parámetros y superponer la curva del modelo usando esos valores. >
plot(x, y) > xfit < seq(.02, 1.1,
.05) > yfit < 200 *
xfit/(0.1 + xfit) > líneas(spline(xfit, yfit))
Podríamos hacerlo mejor, pero estos valores iniciales de 200 y 0,1 parecen adecuados. Ahora haz el ajuste:
> salida < nlm(fn, p = c(200, 0.1), arpillera = VERDADERO)
Después del ajuste, out$minimum es el SSE y out$estimate son las estimaciones de mínimos cuadrados.
de los parámetros. Para obtener los errores estándar aproximados (SE) de las estimaciones hacemos:
> sqrt(diag(2*salida$mínimo/(longitud(y) 2) * resolver(salida$hessiano)))
El 2 que se resta en la línea de arriba representa el número de parámetros. Un intervalo de confianza del 95% sería la
estimación del parámetro ± 1,96 SE. Podemos superponer el ajuste de mínimos cuadrados en un nuevo gráfico: > plot(x, y) >
xfit < seq(.02, 1.1, .05) > yfit <
212.68384222 *
xfit/(0.06412146 + xfit) > líneas(spline (xfit,
yfit))
El paquete estándar stats proporciona funciones mucho más amplias para ajustar modelos no lineales mediante mínimos
cuadrados. El modelo que acabamos de instalar es el modelo MichaelisMenten, por lo que
puedo usar
> df < data.frame(x=x, y=y) > ajuste < nls(y

~ SSmicmen(x, Vm, K), df)
> encajar
Modelo de regresión no lineal

y datos: df ~ SSmicmen(x, Vm, K) modelo:
Vm k
212.68370711 0.06412123
suma de cuadrados residual: 1195.449 > resumen(ajuste)
Formula: y ~ SSmicmen(x, Vm, K)
Parámetros:
Estimar estándar Valor t de error Pr(>|t|)
Vm 2.127e+02 6.947e+00 30.615 3.24e11
K 6.412e02 8.281e03 7.743 1.57e05
Error estándar residual: 10,93 en 10 grados de libertad
Correlación de estimaciones de parámetros:

Vm
k 0,7651
11.7.2 Máxima probabilidad
La máxima verosimilitud es un método de ajuste de modelos no lineales que se aplica incluso si los errores no son normales. El
método encuentra los valores de los parámetros que maximizan la probabilidad logarítmica, o
de manera equivalente que minimizan la probabilidad logarítmica negativa. He aquí un ejemplo de Dobson (1990),
págs. 108111. Este ejemplo ajusta un modelo logístico a los datos dosisrespuesta, que claramente también podría
ajustarse mediante glm(). Los datos son:
> x < c(1.6907, 1.7242, 1.7552, 1.7842, 1.8113,
1,8369, 1,8610, 1,8839) > y <
c( 6, 13, 18, 28, 52, 53, 61, 60) > n < c(59, 60, 62, 56, 63,
59, 62, 60)
La probabilidad logarítmica negativa a minimizar es:
> fn < función(p)
suma( (y*(p[1]+p[2]*x) n*log(1+exp(p[1]+p[2]*x)) + log(elegir(n, y) ) ))
Elegimos valores iniciales razonables y hacemos el ajuste:

> out < nlm(fn, p = c(50,20), hessian = TRUE)
Después del ajuste, out$minimum es la probabilidad logarítmica negativa y out$estimate son las estimaciones de
máxima verosimilitud de los parámetros. Para obtener los SE aproximados de las estimaciones hacemos:
> sqrt(diag(resolver(out$hessian)))
Un intervalo de confianza del 95% sería la estimación del parámetro ± 1,96 SE.
11.8 Algunos modelos no estándar

Concluimos este capítulo con sólo una breve mención de algunas de las otras funciones disponibles en R para
problemas especiales de regresión y análisis de datos. •
Modelos mixtos. El paquete nlme recomendado (https://CRAN.Rproject.org/package=nlme) proporciona funciones
lme() y nlme() para modelos de efectos mixtos lineales y no lineales, es decir, regresiones lineales y no lineales
en algunos de los coeficientes corresponden a efectos aleatorios. Estas funciones hacen un uso intensivo de
fórmulas para especificar los modelos. • Regresiones locales aproximadas. La función loess() ajusta
una regresión no paramétrica utilizando una regresión ponderada localmente. Estas regresiones son útiles para
resaltar una tendencia en datos desordenados o para reducir datos y dar una idea de un gran conjunto de datos.
La función loess se encuentra en el paquete estándar stats, junto con el código para la regresión de búsqueda
de proyección.
• Regresión robusta. Hay varias funciones disponibles para ajustar modelos de regresión de forma resistente a la
influencia de valores atípicos extremos en los datos. La función lqs en el paquete recomendado MASS (https://
CRAN.Rproject.org/package=MASS) proporciona algoritmos de última generación para ajustes altamente
resistentes. Hay métodos menos resistentes pero estadísticamente más eficientes disponibles en paquetes, por
ejemplo la función rlm en el paquete MASS (https://CRAN.Rproject.org/package=MASS ).
• Modelos aditivos. Esta técnica tiene como objetivo construir una función de regresión a partir de funciones aditivas
suaves de las variables determinantes, generalmente una para cada variable determinante. Funciones avas y
ace en el paquete acepack (https://CRAN.Rproject.org/package=acepack) y funciones bruto y mars en el
paquete mda (https://CRAN.Rproject.org/paquete=mda ) proporcione algunos ejemplos de estas técnicas en
paquetes aportados por el usuario para R. Una extensión son los Modelos aditivos generalizados, implementados
en paquetes aportados por el usuario gam (https://CRAN. Rproject. org/paquete=gam) y mgcv ( https : // GRÚA .
Rproject.org/package=mgcv).
• Modelos basados en árboles. En lugar de buscar un modelo lineal global explícito para la predicción o interpretación,
los modelos basados en árboles buscan bifurcar los datos, recursivamente, en puntos críticos de las variables
determinantes para finalmente dividir los datos en grupos que sean
lo más homogéneo posible dentro y lo más heterogéneo posible entre sí. Los resultados a menudo
conducen a conocimientos que otros métodos de análisis de datos tienden a no generar.
Los modelos se especifican nuevamente en la forma de modelo lineal ordinario. La función de ajuste del
modelo es tree(), pero muchas otras funciones genéricas como plot() y text() están bien adaptadas para
mostrar los resultados de un ajuste de modelo basado en árbol de forma gráfica.
Los modelos de árbol están disponibles en R a través de los paquetes aportados por el usuario rpart
(https: // CRAN . Rproject . org / package=rpart) y tree (https: // CRAN . Rproject . org / package=tree).
Capítulo 12: Procedimientos gráficos 63
12 procedimientos gráficos
Las funciones gráficas son un componente importante y extremadamente versátil del entorno R.
Es posible utilizar las funciones para mostrar una amplia variedad de gráficos estadísticos y también para crear tipos de
gráficos completamente nuevos.
Las funciones de gráficos se pueden utilizar tanto en modo interactivo como por lotes, pero en la mayoría de los
casos, el uso interactivo es más productivo. El uso interactivo también es fácil porque en el momento del inicio R inicia
un controlador de dispositivo de gráficos que abre una ventana de gráficos especial para la visualización de gráficos
interactivos. Aunque esto se hace automáticamente, puede ser útil saber que el comando utilizado es X11() en UNIX,
windows() en Windows y quartz() en OS X. Siempre se puede abrir un nuevo dispositivo mediante dev.new().
Una vez que se está ejecutando el controlador del dispositivo, los comandos de trazado de R se pueden usar para producir una variedad de
presentaciones gráficas y crear tipos de visualización completamente nuevos.
Los comandos de trazado se dividen en tres grupos básicos:
• Las funciones de trazado de alto nivel crean un nuevo trazado en el dispositivo gráfico, posiblemente con ejes,
etiquetas, títulos, etc.
• Las funciones de trazado de bajo nivel añaden más información a un trazado existente, como puntos adicionales,
líneas y etiquetas.
• Las funciones de gráficos interactivos le permiten agregar o extraer información de forma interactiva.
mación a partir de un gráfico existente, utilizando un dispositivo señalador como un ratón.
Además, R mantiene una lista de parámetros gráficos que pueden manipularse para personalizar sus gráficos.
Este manual sólo describe lo que se conoce como gráficos "base". Un subsistema de gráficos independiente en el
paquete grid coexiste con la base: es más potente pero más difícil de usar. Hay un paquete de celosía recomendado
(https://CRAN.Rproject.org/package=lattice) que se basa en una cuadrícula y proporciona formas de producir gráficos
de paneles múltiples similares a los del sistema Trellis en S.
12.1 Comandos de trazado de alto nivel

Las funciones de trazado de alto nivel están diseñadas para generar un gráfico completo de los datos pasados como
argumentos a la función. Cuando corresponda, los ejes, etiquetas y títulos se generan automáticamente (a menos que
usted solicite lo contrario). Los comandos de trazado de alto nivel siempre inician un nuevo trazado, borrando el trazado
actual si es necesario.
12.1.1 La función plot() Una de las funciones
de trazado más utilizadas en R es la función plot(). Esta es una función genérica: el tipo de trama producida depende
del tipo o clase del primer argumento.
plot(x, y)
plot(xy) Si x e y son vectores, plot(x, y) produce un diagrama de dispersión de y frente a x. Se puede producir el mismo
efecto proporcionando un argumento (segunda forma) como una lista que contiene dos elementos xey o
una matriz de dos columnas.
plot(x) Si x es una serie de tiempo, esto produce un gráfico de serie de tiempo. Si x es un vector numérico, produce una
gráfica de los valores del vector frente a su índice en el vector. Si x es un vector complejo, produce una
gráfica de las partes imaginarias versus reales de los elementos del vector.
plot(f)
plot(f, y) f es
un objeto factor, y es un vector numérico. La primera forma genera un diagrama de barras de f; la segunda
forma produce diagramas de caja de y para cada nivel de f.
plot(df)
plot(~ expr) plot(y
~ expr) df es un
marco de datos, y es cualquier objeto, expr es una lista de nombres de objetos separados por '+' (por
ejemplo, a + b + c). Las dos primeras formas producen gráficos de distribución de las variables en un marco
de datos (primera forma) o de una serie de objetos con nombre (segunda forma). La tercera forma traza y
contra cada objeto nombrado en expr.
12.1.2 Visualización de datos multivariados R proporciona
dos funciones muy útiles para representar datos multivariados. Si X es una matriz numérica o un marco de datos, el
comando
> pares(X)
produce una matriz de diagrama de dispersión por pares de las variables definidas por las columnas de X, es decir, cada
columna de X se traza contra cada otra columna de X y los n(n − 1) gráficos resultantes se organizan en una matriz con
escalas de diagrama constantes las filas y columnas de la matriz.
Cuando intervienen tres o cuatro variables, un complot puede ser más esclarecedor. Si a y b son vectores numéricos y
c es un vector numérico o un objeto factor (todos de la misma longitud), entonces el comando
> coplot(a ~ b | c) produce

un número de diagramas de dispersión de a frente a b para valores dados de c. Si c es un factor, esto simplemente significa
que a se traza contra b para cada nivel de c. Cuando c es numérico, se divide en varios intervalos de condicionamiento y
para cada intervalo se traza a contra b para los valores de c dentro del intervalo. El número y la posición de los intervalos
se pueden controlar con el argumento dado.values= de coplot(); la función co.intervals() es útil para seleccionar intervalos.
También puedes usar dos variables dadas con un comando como > coplot(a ~ b | c + d)
que produce diagramas de dispersión de a contra b para cada intervalo de condicionamiento conjunto de cy d.
Las funciones coplot() y pairs() toman un argumento panel= que se puede utilizar para personalizar el tipo de gráfico
que aparece en cada panel. El valor predeterminado es puntos() para producir un diagrama de dispersión, pero al
proporcionar alguna otra función gráfica de bajo nivel de dos vectores xey como valor de panel= puede producir cualquier
tipo de gráfico que desee. Un ejemplo de función de panel útil para coplots es panel.smooth().
12.1.3 Mostrar gráficos

Otras funciones de gráficos de alto nivel producen diferentes tipos de gráficos. Algunos ejemplos son:
qqnorm(x)
qqline(x)
qqplot(x, y)
Gráficos de comparación de distribución. La primera forma traza el vector numérico x frente a las
puntuaciones de orden normal esperadas (una gráfica de puntuaciones normales) y la segunda agrega una
línea recta a dicha gráfica trazando una línea que atraviesa los cuartiles de distribución y datos.
La tercera forma traza los cuantiles de x contra los de y para comparar sus respectivos
distribuciones.
hist(x)
hist(x, nclase=n) hist(x,
descansos=b, ...)
Produce un histograma del vector numérico x. Generalmente se elige un número razonable de clases, pero
se puede dar una recomendación con el argumento nclass=.
Alternativamente, los puntos de interrupción se pueden especificar exactamente con el argumento breaks=.
Capítulo 12: Procedimientos gráficos sesenta y cinco
Si se da el argumento probabilidad=VERDADERO, las barras representan frecuencias relativas divididas por el

ancho del contenedor en lugar de recuentos.
diagrama de puntos(x, ...)

Construye un diagrama de puntos de los datos en x. En un diagrama de puntos, el eje y proporciona un etiquetado
de los datos en x y el eje x proporciona su valor. Por ejemplo, permite una fácil selección visual de todas las
entradas de datos con valores que se encuentran en rangos específicos.
imagen(x, y, z, ...) contorno(x,

y, z, ...) persp(x, y, z, ...)
Parcelas de tres variables. El gráfico de imagen dibuja una cuadrícula de rectángulos usando diferentes colores
para representar el valor de z, el gráfico de contorno dibuja líneas de contorno para representar el valor de z y el
gráfico persp dibuja una superficie 3D.
12.1.4 Argumentos para funciones de trazado de alto nivel

Hay una serie de argumentos que se pueden pasar a funciones gráficas de alto nivel, como se muestra a continuación:
add=TRUE Fuerza que la función actúe como una función de gráficos de bajo nivel, superponiendo el gráfico al gráfico actual (solo
algunas funciones).
axes=FALSE
Suprime la generación de ejes; útil para agregar sus propios ejes personalizados con la función axis(). El valor
predeterminado, ejes = VERDADERO, significa incluir ejes.
log="x"
log="y"
log="xy" Hace que los ejes x, y o ambos sean logarítmicos. Esto funcionará para muchos tipos de trama, pero no para todos.
tipo = El argumento type= controla el tipo de gráfico producido, de la siguiente manera: type="p"
Traza puntos individuales (el valor predeterminado)
type="l" Trazar líneas type="b"
Trazar puntos conectados por líneas (ambas) type="o" Trazar
puntos superpuestos por líneas type="h" Trazar líneas
verticales desde los puntos hasta el eje cero (alta densidad)
type="s"
type="S" Gráficos de función escalonada. En la primera forma, la parte superior de la vertical define el punto; en el
segundo, el fondo.
type="n" Sin trazado en absoluto. Sin embargo, los ejes todavía se dibujan (de forma predeterminada) y el sistema
de coordenadas se configura de acuerdo con los datos. Ideal para crear gráficos con funciones
gráficas posteriores de bajo nivel.
xlab=string
ylab=string
Etiquetas de eje para los ejes xey. Utilice estos argumentos para cambiar las etiquetas predeterminadas, normalmente
los nombres de los objetos utilizados en la llamada a la función de trazado de alto nivel.
main=string Título
de la figura, colocado en la parte superior del gráfico en una fuente grande.
sub=string
Subtítulo, colocado justo debajo del eje x en una fuente más pequeña.
12.2 Comandos de trazado de bajo nivel

A veces, las funciones de trazado de alto nivel no producen exactamente el tipo de trama que desea.
En este caso, se pueden utilizar comandos de trazado de bajo nivel para agregar información adicional (como puntos,
líneas o texto) al trazado actual.
Algunas de las funciones de trazado de bajo nivel más útiles son:
puntos(x, y)
líneas(x, y)
Agrega puntos o líneas conectadas al gráfico actual. El argumento type= de plot() también se puede
pasar a estas funciones (y el valor predeterminado es "p" para puntos() y "l" para líneas()).
texto(x, y, etiquetas, ...)

Agregue texto a una gráfica en puntos dados por x, y. Normalmente, las etiquetas son un número
entero o un vector de caracteres, en cuyo caso las etiquetas [i] se trazan en el punto (x [i], y [i]). El
valor predeterminado es 1:longitud(x).
Nota: Esta función se utiliza a menudo en la secuencia
> trama(x, y, tipo="n"); texto (x, y, nombres)
El parámetro de gráficos type="n" suprime los puntos pero configura los ejes, y la función text()
proporciona caracteres especiales, según lo especificado por los nombres de los vectores de caracteres
para los puntos.
abline(a, b)
abline(h=y)
abline(v=x)
abline(lm.obj)
Agrega una línea de pendiente b e intercepta a al gráfico actual. h=y se puede utilizar para especificar
las coordenadas y para las alturas de las líneas horizontales que atraviesan un gráfico, y v=x de
manera similar para las coordenadas x de las líneas verticales. Además, lm.obj puede ser una lista
con un componente de coeficientes de longitud 2 (como el resultado de funciones de ajuste del
modelo) que se toman como una intersección y una pendiente, en ese orden.
polígono(x, y, ...)
Dibuja un polígono definido por los vértices ordenados en (x, y) y (opcionalmente) lo sombrea con
líneas de sombreado, o lo rellena si el dispositivo gráfico permite el relleno de figuras.
leyenda(x, y, leyenda, ...)

Agrega una leyenda al gráfico actual en la posición especificada. Los caracteres de trazado, estilos de
línea, colores, etc., se identifican con las etiquetas en la leyenda del vector de caracteres. También se
debe dar al menos otro argumento v (un vector de la misma longitud que la leyenda) con los valores
correspondientes de la unidad de trazado, como sigue:
leyenda( , relleno=v)
Colores para cajas llenas
leyenda( , col=v)
Colores en los que se dibujarán puntos o líneas.
leyenda( ,lty=v)
Estilos de línea
leyenda( , lwd=v)
Anchos de línea
leyenda( , pch=v)
Trazar caracteres (vector de caracteres)
título (principal, sub)

Agrega un título principal en la parte superior del gráfico actual en una fuente grande y (opcionalmente) un
subtítulo en la parte inferior en una fuente más pequeña.
eje(lado, ...)
Agrega un eje al gráfico actual en el lado dado por el primer argumento (1 a 4, contando en el sentido de
las agujas del reloj desde abajo). Otros argumentos controlan la posición del eje dentro o al lado del gráfico,
y marcan posiciones y etiquetas. Útil para agregar ejes personalizados después de llamar a plot() con el
argumento axes=FALSE.
Las funciones de trazado de bajo nivel normalmente requieren cierta información de posicionamiento (por ejemplo,
coordenadas xey) para determinar dónde colocar los nuevos elementos del trazado. Las coordenadas se dan en términos
de coordenadas de usuario que se definen mediante el comando de gráficos de alto nivel anterior y se eligen en función
de los datos proporcionados.
Cuando se requieren argumentos xey, también es suficiente proporcionar un único argumento que sea una lista con
elementos denominados xey. De manera similar, una matriz con dos columnas también es una entrada válida.
De esta manera, se pueden utilizar funciones como locator() (ver más abajo) para especificar posiciones en un gráfico de
forma interactiva.
12.2.1 Anotación matemática

En algunos casos, resulta útil agregar símbolos y fórmulas matemáticas a un gráfico. Esto se puede lograr en R
especificando una expresión en lugar de una cadena de caracteres en cualquiera de los tipos de texto, textom, eje o título.
Por ejemplo, el siguiente código dibuja la fórmula para la función de probabilidad binomial:
> texto(x, y, expresión(pegar(bgroup("(", encima(n, x), ")"), p^x, q^{nx})))

Puede obtener más información, incluida una lista completa de las funciones disponibles, desde dentro
R usando los comandos:
> ayuda(plotmath) >

ejemplo(plotmath) >
demostración(plotmath)
12.2.2 Fuentes vectoriales Hershey Es posible
especificar fuentes vectoriales Hershey para representar texto cuando se utilizan las funciones de texto y contorno. Hay
tres razones para utilizar las fuentes Hershey:
• Las fuentes Hershey pueden producir mejores resultados, especialmente en la pantalla de una computadora, para rotaciones.
y/o texto pequeño.
• Las fuentes Hershey proporcionan ciertos símbolos que pueden no estar disponibles en las fuentes estándar. En
particular, existen signos del zodíaco, símbolos cartográficos y símbolos astronómicos.
• Las fuentes Hershey proporcionan caracteres cirílicos y japoneses (kana y kanji).
Se puede obtener más información, incluidas tablas de caracteres de Hershey, desde R

usando los comandos: >
ayuda (Hershey) >

demostración (Hershey)
> ayuda (japonés) >
demostración (japonés)
12.3 Interactuar con gráficos

R también proporciona funciones que permiten a los usuarios extraer o agregar información a un gráfico usando el mouse.
La más simple de ellas es la función locator():
localizador(n, tipo)
Espera a que el usuario seleccione ubicaciones en el gráfico actual usando el botón izquierdo del mouse.
Esto continúa hasta que se hayan seleccionado n (predeterminado 512) puntos o se presione otro botón
del mouse. El argumento tipo permite trazar en los puntos seleccionados y tiene el mismo efecto que los
comandos de gráficos de alto nivel; el valor predeterminado es no trazar. locator() devuelve las
ubicaciones de los puntos seleccionados como una lista con dos componentes xey.
locator() generalmente se llama sin argumentos. Es particularmente útil para seleccionar de forma interactiva
posiciones para elementos gráficos como leyendas o etiquetas cuando es difícil calcular de antemano dónde se debe
colocar el gráfico. Por ejemplo, para colocar texto informativo cerca de un punto periférico, el comando > text(locator(1),
"Outlier", adj=0)
puede ser útil. (El localizador() se ignorará si el dispositivo actual, como PostScript, no admite el apuntamiento
interactivo.) identificar(x, y, etiquetas)
Permita al usuario resaltar cualquiera de los puntos definidos por xey (usando el botón izquierdo del
mouse) trazando el componente correspondiente de las etiquetas cercanas (o el número de índice del
punto si no hay etiquetas). Devuelve los índices de los puntos seleccionados cuando se presiona otro
botón.
A veces queremos identificar puntos particulares de una trama, en lugar de sus posiciones. Por ejemplo, podemos
desear que el usuario seleccione alguna observación de interés de una visualización gráfica y luego manipule esa
observación de alguna manera. Dado un número de coordenadas (x, y) en dos vectores numéricos xey, podríamos usar
la función identificar() de la siguiente manera:
> trazar(x, y) >
identificar(x, y)
Las funciones identificar() no realizan ningún trazado en sí, sino que simplemente permiten al usuario mover el
puntero del mouse y hacer clic con el botón izquierdo del mouse cerca de un punto. Si hay un punto cerca del puntero
del mouse, se marcará con su número de índice (es decir, su posición en los vectores x/y) trazado cerca. Alternativamente,
puede usar alguna cadena informativa (como el nombre de un caso) como resaltado usando el argumento de etiquetas
para identificar(), o deshabilitar el marcado por completo con el argumento plot = FALSE. Cuando finaliza el proceso (ver
arriba), identificar() devuelve los índices de los puntos seleccionados; Puede utilizar estos índices para extraer los puntos
seleccionados de los vectores originales xey.
12.4 Uso de parámetros gráficos

Al crear gráficos, particularmente con fines de presentación o publicación, los valores predeterminados de R no siempre
producen exactamente lo que se requiere. Sin embargo, puedes personalizar casi todos los aspectos de la pantalla
utilizando parámetros gráficos. R mantiene una lista de una gran cantidad de parámetros gráficos que controlan aspectos
como el estilo de línea, los colores, la disposición de las figuras y la justificación del texto, entre muchos otros. Cada
parámetro gráfico tiene un nombre (como 'col', que controla los colores) y un valor (un número de color, por ejemplo).
Se mantiene una lista separada de parámetros gráficos para cada dispositivo activo, y cada dispositivo tiene un
conjunto predeterminado de parámetros cuando se inicializa. Los parámetros gráficos se pueden configurar de dos
maneras: de forma permanente, afectando a todas las funciones gráficas que acceden al dispositivo actual; o
temporalmente, afectando sólo a una única llamada de función gráfica.
12.4.1 Cambios permanentes: la función par() La función par() se utiliza para
acceder y modificar la lista de parámetros gráficos para el dispositivo gráfico actual.

acerca de() Sin argumentos, devuelve una lista de todos los parámetros gráficos y sus valores para el dispositivo actual.
par(c("col", "lty"))
Con un argumento de vector de caracteres, devuelve solo los parámetros de gráficos nombrados
(nuevamente, como una lista).
par(col=4, lty=2)
Con argumentos con nombre (o un argumento de lista única), establece los valores de los parámetros
gráficos con nombre y devuelve los valores originales de los parámetros como una lista.
La configuración de parámetros gráficos con la función par() cambia el valor de los parámetros de forma permanente,
en el sentido de que todas las llamadas futuras a funciones gráficas (en el dispositivo actual) se verán afectadas por el
nuevo valor. Puede pensar en configurar los parámetros gráficos de esta manera como establecer valores "predeterminados"
para los parámetros, que serán utilizados por todas las funciones gráficas a menos que se proporcione un valor alternativo.
Tenga en cuenta que las llamadas a par() siempre afectan los valores globales de los parámetros gráficos, incluso
cuando se llama a par() desde dentro de una función. Este suele ser un comportamiento indeseable; normalmente queremos
establecer algunos parámetros gráficos, realizar algunos trazados y luego restaurar los valores originales para no afectar la
sesión R del usuario. Puede restaurar los valores iniciales guardando el resultado de par() al realizar cambios y restaurando
los valores iniciales cuando se complete el trazado. > par antiguo < par(col=4, lty=2) . Comandos de
trazado. . > par(par anterior)
.. .
Para guardar y restaurar todos los parámetros gráficos configurables1,

utilice > oldpar < par(no.readonly=TRUE) .
. . Comandos de trazado. . > .
par(par anterior)
12.4.2 Cambios temporales: argumentos para funciones gráficas Los parámetros gráficos también se
pueden pasar a (casi) cualquier función gráfica como argumentos con nombre.
Esto tiene el mismo efecto que pasar los argumentos a la función par(), excepto que los cambios solo duran mientras dura
la llamada a la función. Por ejemplo: > plot(x, y, pch="+") produce un diagrama
de dispersión utilizando un signo
más como carácter de trazado, sin cambiar el carácter de trazado predeterminado para futuros gráficos.
Desafortunadamente, esto no se implementa de manera totalmente consistente y a veces es necesario

configure y restablezca los parámetros gráficos usando par().
12.5 Lista de parámetros de gráficos

Las siguientes secciones detallan muchos de los parámetros gráficos comúnmente utilizados. La documentación de ayuda
de R para la función par() proporciona un resumen más conciso; esto se proporciona como una alternativa algo más
detallada.
Los parámetros gráficos se presentarán de la siguiente forma:

nombre=valor
Una descripción del efecto del parámetro. nombre es el nombre del parámetro, es decir, el nombre del
argumento que se utilizará en las llamadas a par() o una función gráfica. value es un valor típico que puede
utilizar al configurar el parámetro.
Tenga en cuenta que los ejes no son un parámetro de gráficos sino un argumento para algunos métodos de trazado:
consulte xaxt y yaxt.
1
Algunos parámetros gráficos, como el tamaño del dispositivo actual, son sólo informativos.
12.5.1 Elementos gráficos Los gráficos R se
componen de puntos, líneas, texto y polígonos (regiones rellenas). Existen parámetros gráficos que controlan cómo se
dibujan estos elementos gráficos, de la siguiente manera:
pch="+" Carácter que se utilizará para trazar puntos. El valor predeterminado varía según los controladores de gráficos, pero
suele ser '◦'. Los puntos trazados tienden a aparecer ligeramente por encima o por debajo de la posición
adecuada a menos que utilice "." como personaje de trazado, que produce puntos centrados.
pch=4 Cuando pch se da como un número entero entre 0 y 25 inclusive, se produce un símbolo de trazado
especializado. Para ver cuáles son los símbolos, use el comando
> leyenda(localizador(1), como.carácter(0:25), pch = 0:25)
Los del 21 al 25 pueden parecer duplicados de símbolos anteriores, pero se pueden colorear de diferentes
maneras: consulte la ayuda sobre los puntos y sus ejemplos.
Además, pch puede ser un carácter o un número en el rango 32:255 que representa un carácter en la fuente
actual.
lty=2 Tipos de línea. Los estilos de línea alternativos no son compatibles con todos los dispositivos gráficos (y
varían según los que sí lo hacen), pero el tipo de línea 1 es siempre una línea sólida, el tipo de línea 0
siempre es invisible y los tipos de línea 2 y posteriores son líneas de puntos o de guiones, o algunas
combinación de ambos.
lwd=2 Anchos de línea. Ancho de línea deseado, en múltiplos del ancho de línea "estándar".
Afecta a las líneas de los ejes, así como a las líneas dibujadas con líneas(), etc. No todos los dispositivos
admiten esto y algunos tienen restricciones en los anchos que se pueden usar.
columna=2 Colores que se utilizarán para puntos, líneas, texto, regiones rellenas e imágenes. Un número de la paleta
actual (ver ?paleta) o un color con nombre.
eje col.
laboratorio col.
col.main
col.sub El color que se utilizará para la anotación de los ejes, las etiquetas x e y, los títulos principales y los subtítulos,
respectivamente.
font=2 Un número entero que especifica qué fuente usar para el texto. Si es posible, los controladores de dispositivos se
organizan de modo que 1 corresponda a texto sin formato, 2 a negrita, 3 a cursiva, 4 a negrita cursiva y 5 a
una fuente de símbolo (que incluye letras griegas).
fuente.eje
font.lab
fuente.principal
font.sub La fuente que se utilizará para la anotación de ejes, etiquetas x e y, títulos principales y subtítulos, respectivamente.
activamente.
adj=0.1 Justificación del texto relativa a la posición de trazado. 0 significa justificar a la izquierda, 1 significa justificar a la
derecha y 0,5 significa centrar horizontalmente alrededor de la posición de trazado. El valor real es la
proporción de texto que aparece a la izquierda de la posición de trazado, por lo que un valor de 0,1 deja un
espacio del 10% del ancho del texto entre el texto y la posición de trazado.
cex=1.5 Expansión de personaje. El valor es el tamaño deseado de los caracteres de texto (incluidos los caracteres de
trazado) en relación con el tamaño de texto predeterminado.
eje.cex
cex.lab
cex.main
cex.sub La expansión de caracteres que se utilizará para la anotación de ejes, etiquetas x e y, títulos principales y subtítulos,
respectivamente.
12.5.2 Ejes y marcas

Muchos de los gráficos de alto nivel de R tienen ejes, y usted mismo puede construir ejes con la función de gráficos de bajo
nivel axis(). Los ejes tienen tres componentes principales: la línea del eje (estilo de línea controlado por el parámetro de
gráficos lty), las marcas de graduación (que marcan las divisiones de unidades a lo largo de la línea del eje) y las etiquetas
de graduación (que marcan las unidades). Estos componentes se pueden personalizar con los siguientes parámetros gráficos.
laboratorio=c(5, 7, 12)
Los primeros dos números son el número deseado de intervalos de tick en los ejes xey respectivamente. El
tercer número es la longitud deseada de las etiquetas de los ejes, en caracteres (incluido el punto decimal).
Si elige un valor demasiado pequeño para este parámetro, es posible que todas las etiquetas de marca se
redondeen al mismo número.
las=1 Orientación de las etiquetas de los ejes. 0 significa siempre paralelo al eje, 1 significa siempre horizontal y 2
significa siempre perpendicular al eje.
mgp=c(3, 1, 0)
Posiciones de los componentes del eje. El primer componente es la distancia desde la etiqueta del eje hasta
la posición del eje, en líneas de texto. El segundo componente es la distancia a las etiquetas de marca y el
componente final es la distancia desde la posición del eje hasta la línea del eje (generalmente cero). Los
números positivos miden fuera de la región de la trama, los negativos
números en el interior.
tck=0,01 Longitud de las marcas, como fracción del tamaño de la región de trazado. Cuando tck es pequeño (menos de 0,5),
las marcas en los ejes xey se ven obligadas a tener el mismo tamaño. Un valor de 1 proporciona líneas de
cuadrícula. Los valores negativos dan marcas fuera de la región de trazado. Utilice tck=0.01 y mgp=c(1,1.5,0)
para las marcas internas.
xaxs="r"
yaxs="i" Estilos de eje para los ejes x e y, respectivamente. Con los estilos "i" (interno) y "r" (predeterminado), las marcas de
verificación siempre caen dentro del rango de los datos; sin embargo, el estilo "r" deja una pequeña cantidad
de espacio en los bordes. (S tiene otros estilos no implementados en R.)
12.5.3 Márgenes de la figura Un gráfico
único en R se conoce como figura y comprende una región del gráfico rodeada por márgenes (que posiblemente contengan
etiquetas de ejes, títulos, etc.) y (normalmente) delimitada por los propios ejes.
Una figura típica es

mar[3]

1 -
0.3
1
1 Región de la trama
1
1
j
1
1
¡
y
0.0
2 de Mayo]
5,1−
0,3−
−3,0 −1,5 0.0 1.5 3.0
Mayo 1] X
Margen
Los parámetros gráficos que controlan el diseño de las figuras incluyen:
más=c(1, 0,5, 0,5, 0)

Anchos de los márgenes inferior, izquierdo, superior y derecho, respectivamente, medidos en pulgadas.
marca=c(4, 2, 2, 1)
Similar a mai, excepto que la unidad de medida son líneas de texto.
mar y mai son equivalentes en el sentido de que establecer uno cambia el valor del otro. El
los valores predeterminados elegidos para este parámetro suelen ser demasiado grandes; el margen derecho rara vez es
necesario, y tampoco lo es el margen superior si no se utiliza ningún título. Los márgenes inferior e izquierdo.
debe ser lo suficientemente grande para acomodar el eje y las etiquetas de marca. Además, el valor predeterminado es
elegido sin tener en cuenta el tamaño de la superficie del dispositivo: por ejemplo, usando el postscript()
El controlador con el argumento altura = 4 dará como resultado un gráfico con un margen de aproximadamente el 50 % a menos que se marque.
o mai se establecen explícitamente. Cuando se utilizan varias figuras (ver más abajo), los márgenes se reducen,
sin embargo, esto puede no ser suficiente cuando muchas figuras comparten la misma página.
12.5.4 Entorno de figuras múltiples R le permite crear una
matriz de figuras de n por m en una sola página. Cada figura tiene sus propios márgenes y, opcionalmente, el conjunto de
figuras está rodeado por un margen exterior, como se muestra en la siguiente figura.

propio[3]

l, -~1 rit l
~. º.J
agua[4]
fabricación=c(3,2,3,2)
agua[1]
mfrow=c(3,2)
Los parámetros gráficos relacionados con varias figuras son los siguientes:
mfcol=c(3, 2)
mfrow=c(2, 4)
Establezca el tamaño de una matriz de varias figuras. El primer valor es el número de filas; el segundo es el
número de columnas. La única diferencia entre estos dos parámetros es que configurar mfcol hace que las
cifras se llenen por columna; mfrow se llena por filas.
El diseño de la Figura podría haberse creado configurando mfrow=c(3,2); la figura muestra la página después
de que se hayan dibujado cuatro diagramas.
Configurar cualquiera de estos puede reducir el tamaño base de los símbolos y el texto (controlado por
par("cex") y el tamaño en puntos del dispositivo). En un diseño con exactamente dos filas y columnas, el
tamaño base se reduce en un factor de 0,83: si hay tres o más filas o columnas, el factor de reducción es 0,66.
fabricación=c(2, 2, 3, 2)
Posición de la figura actual en un entorno de múltiples figuras. Los dos primeros números son la fila y la
columna de la figura actual; los dos últimos son el número de filas y columnas en la matriz de múltiples
figuras. Configure este parámetro para saltar entre figuras en la matriz. Incluso puedes usar valores diferentes
para los dos últimos números que los valores verdaderos para figuras de tamaños desiguales en la misma
página.
fig=c(4, 9, 1, 4)/10 Posición

de la figura actual en la página. Los valores son las posiciones de los bordes izquierdo, derecho, inferior y
superior respectivamente, como porcentaje de la página medido desde la esquina inferior izquierda. El valor
de ejemplo sería para una figura en la parte inferior derecha de la página. Establezca este parámetro para la
colocación arbitraria de figuras dentro de una página. Si desea agregar una figura a una página actual, use
también new=TRUE (a diferencia de S).
propio=c(2, 0, 3, 0)
propio=c(0, 0, 0.8, 0)
Tamaño de los márgenes exteriores. Al igual que mar y mai, el primero mide en líneas de texto y el segundo
en pulgadas, comenzando por el margen inferior y avanzando en el sentido de las agujas del reloj.
Los márgenes exteriores son particularmente útiles para títulos de páginas, etc. Se puede agregar texto a los
márgenes exteriores con la función mtext() con el argumento exterior=TRUE. Sin embargo, no hay márgenes
exteriores de forma predeterminada, por lo que debes crearlos explícitamente usando oma u omi.
Se pueden producir arreglos más complicados de múltiples figuras mediante las funciones split.screen() y
layout(), así como mediante los paquetes grid y lattice (https://CRAN.Rproject.org/ package=lattice) .
12.6 Controladores de dispositivos
R puede generar gráficos (de distintos niveles de calidad) en casi cualquier tipo de pantalla o dispositivo de impresión.
Sin embargo, antes de que esto pueda comenzar, es necesario informar a R con qué tipo de dispositivo está tratando.
Esto se hace iniciando un controlador de dispositivo. El propósito de un controlador de dispositivo es convertir
instrucciones gráficas de R (“dibujar una línea”, por ejemplo) a una forma que el dispositivo en particular pueda
entender.
Los controladores de dispositivos se inician llamando a una función de controlador de dispositivo. Existe una función de este
tipo para cada controlador de dispositivo: escriba ayuda (Dispositivos) para obtener una lista de todos ellos. Por ejemplo, emitiendo
el comando
> posdata()
hace que toda la salida de gráficos futura se envíe a la impresora en formato PostScript. Algunos controladores de
dispositivos comúnmente utilizados son:
X11() Para usar con el sistema de ventanas X11 en sistemas similares a Unix
ventanas()
Para usar en Windows
cuarzo() Para usar en OS X
posdata()
Para imprimir en impresoras PostScript o crear archivos gráficos PostScript.
pdf() Produce un archivo PDF, que también se puede incluir en archivos PDF.
png() Produce un archivo PNG de mapa de bits. (No siempre está disponible: consulte su página de ayuda).
jpeg() Produce un archivo JPEG de mapa de bits, que se utiliza mejor para trazados de imágenes. (No siempre está disponible: consulte
su página de ayuda).
Cuando haya terminado con un dispositivo, asegúrese de finalizar el controlador del dispositivo emitiendo el
comando
> dev.off()
Esto asegura que el dispositivo termine limpiamente; por ejemplo, en el caso de dispositivos de copia impresa,
esto garantiza que cada página esté completa y enviada a la impresora. (Esto sucederá automáticamente al final
normal de una sesión).
12.6.1 Diagramas PostScript para documentos tipográficos Al pasar el argumento

del archivo a la función del controlador de dispositivo postscript(), puede almacenar los gráficos en formato PostScript
en un archivo de su elección. El gráfico tendrá orientación horizontal a menos que se proporcione el argumento
horizontal=FALSE, y puede controlar el tamaño del gráfico con los argumentos ancho y alto (el gráfico se escalará
según corresponda para ajustarse a estas dimensiones).
Por ejemplo, el comando >
postscript("archivo.ps", horizontal=FALSE, altura=5, tamaño en puntos=10)
producirá un archivo que contiene código PostScript para una figura de cinco pulgadas de alto, tal vez para incluirla
en un documento. Es importante tener en cuenta que si el archivo nombrado en el comando ya existe,
será sobrescrito. Este es el caso incluso si el archivo solo se creó anteriormente en la misma sesión de R.
Muchos usos de la salida PostScript serán para incorporar la figura en otro documento. Esto funciona mejor
cuando se produce PostScript encapsulado: R siempre produce una salida conforme, pero solo marca la salida
como tal cuando se proporciona el argumento onefile=FALSE. Esta notación inusual surge de la compatibilidad S:
en realidad significa que el resultado será una sola página (que es parte de la especificación EPSF). Por lo tanto,
para producir un gráfico para su inclusión, use algo como > postscript("plot1.eps", horizontal=FALSE,
onefile=FALSE, height=8, width=6, pointize=10)
12.6.2 Múltiples dispositivos gráficos En el uso

avanzado de R, suele ser útil tener varios dispositivos gráficos en uso al mismo tiempo.
Por supuesto, sólo un dispositivo gráfico puede aceptar comandos gráficos a la vez, y esto se conoce como
dispositivo actual. Cuando hay varios dispositivos abiertos, forman una secuencia numerada con nombres que
indican el tipo de dispositivo en cualquier posición.
Los principales comandos utilizados para operar con múltiples dispositivos y sus significados son los siguientes:
X11() [Unix]
windows()
win.impresora()
win.metafile()
[ventanas]
cuarzo() [OS X]
posdata() pdf()
png()
jpeg()
pelea()
mapa de bits()
... Cada nueva llamada a una función del controlador de dispositivo abre un nuevo dispositivo gráfico,
ampliando así en uno la lista de dispositivos. Este dispositivo se convierte en el dispositivo actual al que
se enviará la salida de gráficos.
lista de desarrollo()
Devuelve el número y nombre de todos los dispositivos activos. El dispositivo en la posición 1 de la

lista es siempre el dispositivo nulo que no acepta ningún comando gráfico.
dev.siguiente()
dev.prev()
Devuelve el número y el nombre del dispositivo gráfico al lado o anterior al dispositivo actual,
respectivamente.
dev.set(que=k)
Se puede utilizar para cambiar el dispositivo gráfico actual al que está en la posición k de la lista de
dispositivos. Devuelve el número y la etiqueta del dispositivo.
dev.off(k)
Termine el dispositivo de gráficos en el punto k de la lista de dispositivos. Para algunos dispositivos,
como los dispositivos Postscript, esto imprimirá el archivo inmediatamente o completará correctamente
el archivo para imprimirlo más tarde, dependiendo de cómo se inició el dispositivo.
dev.copy(dispositivo,..., cual=k)
dev.print(dispositivo,..., cual=k)
Hacer una copia del dispositivo k. Aquí dispositivo es una función de dispositivo, como postscript,
con argumentos adicionales, si es necesario, especificados por '...'. dev.print es similar, pero el
dispositivo copiado se cierra inmediatamente, de modo que las acciones finales, como imprimir
copias impresas, se realizan inmediatamente.
gráficos.off()
Termine todos los dispositivos gráficos de la lista, excepto el dispositivo nulo.
12.7 Gráficos dinámicos

R no tiene capacidades integradas para gráficos dinámicos o interactivos, por ejemplo, rotar nubes de puntos o
“cepillar” (resaltar interactivamente) puntos. Sin embargo, hay amplias funciones de gráficos dinámicos disponibles
en el sistema GGobi de Swayne, Cook y Buja disponible en
http://www.ggobi.org/ y se
puede acceder a ellos desde R a través del paquete rggobi (https://CRAN.Rproject.org/ package=rggobi), descrito
en http://www.ggobi.org /rggobi.
Además, el paquete rgl (https://CRAN.Rproject.org/package=rgl) proporciona formas de interactuar
con trazados 3D, por ejemplo de superficies.
Capítulo 13: Paquetes 77
13 paquetes
Todas las funciones y conjuntos de datos de R se almacenan en paquetes. Sólo cuando se carga un paquete su contenido
está disponible. Esto se hace tanto por eficiencia (la lista completa consumiría más memoria y tardaría más en buscar que un
subconjunto) como para ayudar a los desarrolladores de paquetes, que están protegidos contra conflictos de nombres con
otro código. El proceso de desarrollo de paquetes se describe en la sección “Creación de paquetes R” en Escritura de
extensiones R. Aquí los describiremos desde el punto de vista del usuario.
Para ver qué paquetes están instalados en su sitio, emita el comando
> biblioteca()
sin argumentos. Para cargar un paquete en particular (por ejemplo, el paquete boot (https://CRAN.Rproject. org/package=boot)
que contiene funciones de Davison & Hinkley (1997)), use un comando como
> biblioteca (arranque)
Los usuarios conectados a Internet pueden utilizar las funciones install.packages() y update.packages() (disponibles a
través del menú Paquetes en las GUI de Windows y OS X; consulte la Sección “Instalación de paquetes” en Instalación y
administración de R) para instalar y actualizar paquetes.
Para ver qué paquetes están cargados actualmente, use
> buscar()
para mostrar la lista de búsqueda. Es posible que algunos paquetes estén cargados pero no estén disponibles en la lista de búsqueda
(consulte la Sección 13.3 [Espacios de nombres], página 78): estos se incluirán en la lista proporcionada por
> espacios de nombres cargados()
Para ver una lista de todos los temas de ayuda disponibles en un paquete instalado, use
> ayuda.start()
para iniciar el sistema de ayuda HTML y luego navegue hasta la lista de paquetes en la sección Referencia.
13.1 Paquetes estándar Los paquetes
estándar (o base) se consideran parte del código fuente de R. Contienen las funciones básicas que permiten que R funcione,
y los conjuntos de datos y funciones estadísticas y gráficas estándar que se describen en este manual. Deberían estar
disponibles automáticamente en cualquier instalación de R. Consulte la sección "Paquetes de R" en Preguntas frecuentes de
R para obtener una lista completa.
13.2 Paquetes contribuidos y CRAN

Hay miles de paquetes contribuidos para R, escritos por muchos autores diferentes. Algunos de estos paquetes implementan
métodos estadísticos especializados, otros dan acceso a datos o hardware y otros están diseñados para complementar los
libros de texto. Algunos (los paquetes recomendados) se distribuyen con cada distribución binaria de R. La mayoría están
disponibles para descargar desde CRAN (https://CRAN.Rproject.org/ y sus espejos) y otros repositorios como Bioconductor
(https:// www.bioconductor.org/) y Omegahat (http://www.omegahat.org/). Las preguntas frecuentes de R contienen una lista
de paquetes CRAN vigentes en el momento del lanzamiento, pero la colección de paquetes disponibles cambia con mucha
frecuencia.
Capítulo 13: Paquetes 78
13.3 Espacios de nombres

Todos los paquetes tienen espacios de nombres y los tienen desde R 2.14.0. Los espacios de nombres hacen tres
cosas: permiten que el escritor del paquete oculte funciones y datos que están destinados solo para uso interno,
evitan que las funciones se interrumpan cuando un usuario (u otro escritor del paquete) elige un nombre que choca
con uno en el paquete, y Proporcionar una manera de hacer referencia a un objeto dentro de un paquete en particular.
Por ejemplo, t() es la función de transposición en R, pero los usuarios pueden definir su propia función
denominada t. Los espacios de nombres evitan que la definición del usuario tenga prioridad y rompan cada función
que intenta transponer una matriz.
Hay dos operadores que trabajan con espacios de nombres. El operador de dos puntos :: selecciona definiciones
de un espacio de nombres particular. En el ejemplo anterior, la función de transposición siempre estará disponible
como base::t, porque está definida en el paquete base. De esta manera sólo se pueden recuperar las funciones que
se exportan desde el paquete.
El operador de tres puntos ::: puede verse en algunos lugares del código R: actúa como el operador de dos
puntos pero también permite el acceso a objetos ocultos. Es más probable que los usuarios utilicen la función
getAnywhere(), que busca varios paquetes.
Los paquetes suelen ser interdependientes y cargar uno puede hacer que otros se carguen automáticamente.
Los operadores de dos puntos descritos anteriormente también provocarán la carga automática del paquete
asociado. Cuando los paquetes con espacios de nombres se cargan automáticamente, no se agregan a la lista de
búsqueda.
Capítulo 14: Instalaciones del sistema operativo 79
14 instalaciones del sistema operativo
R tiene facilidades bastante amplias para acceder al sistema operativo bajo el cual se ejecuta: esto le permite usarse como
lenguaje de secuencias de comandos y esa capacidad es muy utilizada por el propio R, por ejemplo, para instalar paquetes.
Debido a que los propios scripts de R deben funcionar en todas las plataformas, se ha realizado un esfuerzo considerable
para que las funciones de scripting sean lo más independientes posible de la plataforma.
14.1 Archivos y directorios
Hay muchas funciones para manipular archivos y directorios. A continuación se ofrecen sugerencias sobre algunos de los más
utilizados.
Para crear un archivo o directorio (vacío), use file.create o create.dir. (Estos son análogos de las utilidades POSIX touch y
mkdir). Para archivos y directorios temporales en el directorio de sesión de R, consulte tempfile.
Los archivos se pueden eliminar mediante file.remove o unlink: este último puede eliminar árboles de directorios.
Para listados de directorios, utilice list.files (también disponible como dir) o list.dirs. Estos pueden seleccionar
archivos que usan una expresión regular: para seleccionar mediante comodines use Sys.glob.
Muchos tipos de información en una ruta de archivo (incluso, por ejemplo, si es un archivo o directorio) pueden
ser encontrado por file.info.
Hay varias formas de saber si un archivo "existe" (un archivo puede existir en el sistema de archivos y no ser visible para el
usuario actual). Hay funciones file.exists, file.access y file_test con varias versiones de esta prueba: file_test es una versión del
comando de prueba POSIX para aquellos familiarizados con los scripts de shell.
La función file.copy es el análogo R del comando POSIX cp.
La elección de archivos se puede hacer de forma interactiva mediante file.choose: el puerto de Windows tiene las funciones
más versátiles elegir.files y elegir.dir y hay funciones similares en el paquete tcltk: tk_choose.files y tk_choose.dir.
Las funciones file.show y file.edit mostrarán y editarán uno o más archivos de una manera apropiada para el puerto R,
utilizando las funciones de una consola (como RGui en Windows o R.app en OS X) si uno está en usar.
Hay cierto soporte para enlaces en el sistema de archivos: consulte las funciones file.link y Sys.readlink.
14.2 Rutas de archivos

Con algunas excepciones, R se basa en las funciones subyacentes del sistema operativo para manipular las rutas de archivos.
Se permite que algunos aspectos de esto dependan del sistema operativo, y lo hacen, incluso hasta la versión del sistema operativo.
Existen estándares POSIX sobre cómo los sistemas operativos deben interpretar las rutas de archivos y muchos usuarios de R
asumen el cumplimiento de POSIX: pero Windows no afirma ser compatible y otros sistemas operativos pueden no ser
completamente compatibles.
Los siguientes son algunos problemas que se han encontrado con las rutas de archivos.
• Los sistemas de archivos POSIX distinguen entre mayúsculas y minúsculas, por lo que foo.png y Foo.PNG son archivos diferentes. Sin
embargo, los valores predeterminados en Windows y OS X no distinguen entre mayúsculas y minúsculas, y los sistemas de archivos
FAT (usados comúnmente en almacenamiento extraíble) normalmente no distinguen entre mayúsculas y minúsculas (y todas las rutas de
archivos pueden asignarse a minúsculas).
• Casi todos los servicios del sistema operativo Windows admiten el uso de barra diagonal o barra invertida como separador de
ruta de archivo, y R convierte las excepciones conocidas al formato requerido por Windows.
• El comportamiento de las rutas de archivos con una barra diagonal depende del sistema operativo. Estas rutas no son válidas en
Windows y no se debe esperar que funcionen. POSIX2008 requiere que dichas rutas coincidan sólo con directorios, pero las
versiones anteriores también les permitían coincidir con archivos. Por eso es mejor evitarlos.
• Varias barras diagonales en rutas de archivos como /abc//def son válidas en sistemas de archivos POSIX y se tratan como si solo
hubiera una barra diagonal. Generalmente son aceptados por las funciones del sistema operativo Windows.
Sin embargo, las barras dobles iniciales pueden tener un significado diferente. • Las rutas
de archivos UNC de Windows \\server\dir1\dir2\file y \\?\UNC\server\dir1\dir2\file)

(semejante
como
no son compatibles, pero pueden funcionar en
algunas funciones de R. Los sistemas de archivos POSIX pueden tratar especialmente una doble barra diagonal inicial. • Windows
permite rutas de archivos que contienen unidades y relativas al directorio actual en una unidad, por ejemplo, d:foo/bar se refiere
a d:/a/b/c/foo/bar si el directorio actual en la unidad d: es /a/b/ C.
Se pretende que funcionen, pero el uso de rutas absolutas es más seguro.
Las funciones nombrebase y nombredir seleccionan partes de una ruta de archivo: la forma recomendada de ensamblar una ruta
de archivo a partir de componentes es archivo.ruta. La función pathexpand realiza una 'expansión de tilde', sustituyendo valores por
directorios de inicio (los del usuario actual y quizás los de otros usuarios).
En sistemas de archivos con enlaces, muchas rutas de archivo pueden hacer referencia a un solo archivo. Función
normalizePath encontrará una ruta de archivo canónica.
Windows tiene los conceptos de nombres de archivos cortos ('8.3') y largos: normalizePath devolverá una ruta absoluta usando
nombres de archivos largos y shortPathName devolverá una versión usando nombres cortos.
Este último no contiene espacios y utiliza una barra invertida como separador, por lo que a veces resulta útil para exportar nombres
desde R.
Los permisos de archivos son un tema relacionado. R admite los conceptos POSIX de permiso de lectura/escritura/ejecución para
propietario/grupo/todos, pero esto puede ser solo parcialmente compatible con el sistema de archivos (por ejemplo, en Windows, solo
archivos de solo lectura (para la cuenta que ejecuta la sesión de R). Se reconocen. Las listas de control de acceso (ACL) se emplean en
varios sistemas de archivos, pero no tienen un estándar acordado y R no tiene instalaciones para controlarlas. Utilice Sys.chmod para
cambiar los permisos.
14.3 Comandos del sistema

Las funciones system y system2 se utilizan para invocar un comando del sistema y, opcionalmente, recopilar su salida. system2 es un
poco más general pero su principal ventaja es que es más fácil escribir código multiplataforma usándolo.
El sistema se comporta de manera diferente en Windows que en otros sistemas operativos (porque la llamada API C con ese
nombre lo hace). En otros lugares, invoca un shell para ejecutar el comando: el puerto Windows de R tiene un shell de funciones para
hacerlo.
Para saber si el sistema operativo incluye un comando, use Sys. Which, que intenta hacerlo de forma multiplataforma
(desafortunadamente, no es un servicio estándar del sistema operativo).
La función shQuote citará las rutas de archivo según sea necesario para los comandos en el sistema operativo actual.
14.4 Compresión y Archivos

Las versiones recientes de R tienen amplias funciones para leer y escribir archivos comprimidos, a menudo de forma transparente. La
lectura de archivos en R se realiza en gran medida mediante conexiones, y la función de archivo que se utiliza para abrir una conexión a
un archivo (o una URL) y es capaz de identificar la compresión utilizada a partir del encabezado "mágico" del archivo.
El tipo de compresión que se ha admitido durante más tiempo es la compresión gzip, y sigue siendo un buen compromiso general.
Los archivos comprimidos con la anterior utilidad de compresión de Unix también se pueden leer, pero cada vez son menos frecuentes.
Otras dos formas de compresión, las del
También están disponibles las utilidades bzip2 y xz. Estos generalmente logran tasas de compresión más altas
(dependiendo del archivo, mucho más altas) a expensas de una descompresión y una compresión mucho más lentas.
Existe cierta confusión entre la compresión xz y lzma (consulte https://en.wikipedia.org/wiki/Xz y https://en.wikipedia.org/

wiki/LZMA): R puede leer archivos comprimidos por la mayoría de las versiones de cualquiera de los dos. .
Los archivos comprimidos son archivos únicos que contienen una colección de archivos, siendo los más comunes los
'tarballs' y los archivos zip que se utilizan para distribuir paquetes R. R puede enumerar y descomprimir ambos (consulte
las funciones descomprimir y descomprimir) y crear ambos (para zip con la ayuda de un programa externo).
Apéndice A: Una sesión de muestra 82
Apéndice AA sesión de muestra

La siguiente sesión tiene como objetivo presentarle algunas características del entorno R mediante su uso. Muchas
características del sistema le resultarán desconocidas y desconcertantes al principio, pero este desconcierto pronto
desaparecerá.
Inicie R de forma adecuada para su plataforma (consulte el Apéndice B [Invocación de R], página 85).
El programa R comienza con un banner.
(Dentro del código R, el mensaje del lado izquierdo no se mostrará para evitar confusiones).
ayuda.start()
Inicie la interfaz HTML para obtener ayuda en línea (usando un navegador web disponible en su
máquina). Debería explorar brevemente las características de esta función con el mouse.
Iconifique la ventana de ayuda y pase a la siguiente parte.
x < norma(50) y <

norma(x)
Genere dos vectores normales pseudoaleatorios de coordenadas xey.
trazar (x, y)
Traza los puntos en el plano. Automáticamente aparecerá una ventana gráfica.
ls() Vea qué objetos de R están ahora en el espacio de trabajo de R.
rm(x, y) Elimina objetos que ya no son necesarios. (Limpiar). x < 1:20
Haz que x = (1, 2, . . . , 20). w < 1 + raíz
cuadrada (x)/2
Un vector de 'peso' de desviaciones estándar.
ficticio < data.frame(x=x, y= x + norma(x)*w)

lm(y ~ Haga un marco de datos de dos columnas, xey, y mírelo. fm ficticio <
x, datos=ficticio) resumen(fm)
Ajuste una regresión lineal simple y observe el análisis. Con y a la izquierda de la tilde, estamos
modelando y dependiendo de x.
fm1 < lm(y ~ x, datos=ficticio, peso=1/w^2) resumen(fm1)
Como conocemos las desviaciones estándar, podemos hacer una regresión ponderada.
adjuntar (ficticio)
Haga que las columnas del marco de datos sean visibles como variables.
lrf < bajo (x, y)

Haga una función de regresión local no paramétrica.
trazar (x, y)
Gráfico de puntos estándar.
lines(x, lrf$y)
Agregue la regresión local.
abline(0, 1, lty=3)
La verdadera recta de regresión: (intersección 0, pendiente 1).
abline(coef(fm))
Línea de regresión no ponderada.
abline(coef(fm1), col = "rojo")

Línea de regresión ponderada.
detach() Elimina el marco de datos de la ruta de búsqueda.
plot(ajustado(fm), resid(fm), xlab="Valores

ajustados", ylab="Residuales",
main="Residuales vs
Ajustados")
Un gráfico de diagnóstico de regresión estándar para comprobar la heterocedasticidad. ¿Puedes verlo?
qqnorm(resid(fm), main="Gráfico de Rankit de residuos")

Un gráfico de puntuaciones normales para comprobar si hay asimetría, curtosis y valores atípicos. (No es muy útil
aquí).
rm(fm, fm1, lrf, x, tonto)

Limpiar de nuevo.
La siguiente sección analizará los datos del experimento clásico de Michelson para medir la velocidad de la luz. Este conjunto
de datos está disponible en el objeto morley, pero lo leeremos para ilustrar la función read.table.
ruta de archivo < system.file("data", "morley.tab" , paquete="datasets") ruta de archivo Obtenga la ruta al
archivo de datos.
archivo.mostrar(rutadelarchivo)
Opcional. Mira el archivo.
mm < read.table(ruta de archivo)

milímetros
Lea los datos de Michelson como un marco de datos y mírelos. Hay cinco experimentos (columna Expt) y cada
uno tiene 20 ejecuciones (columna Ejecutar) y sl es la velocidad de la luz registrada, adecuadamente codificada.
mm$Expt < factor(mm$Expt) mm$Ejecutar

< factor(mm$Ejecutar)
Cambie Expt y Run into factores.
adjuntar (mm)
Haga que el marco de datos sea visible en la posición 3 (el valor predeterminado).
plot(Expt, Velocidad, main="Datos de velocidad de la luz", xlab="Nº de experimento")

Compara los cinco experimentos con diagramas de caja simples.
fm < aov(Velocidad ~ Ejecutar + Expt, datos=mm)

resumen(fm)
Analice como un bloque aleatorio, con "ejecuciones" y "experimentos" como factores.
~
fm0 < actualizar(fm, .anova(fm0, . Correr)
fm)
Ajuste el submodelo omitiendo las 'ejecuciones' y compare utilizando un análisis de varianza formal.
separar()
rm(fm, fm0)
Limpia antes de continuar.
Ahora veremos algunas características más gráficas: trazados de contornos e imágenes.
x < seq(pi, pi, len=50) y < x

x es un vector de 50 valores equiespaciados en −π ≤ x ≤ π. y es lo mismo.
f < outside(x, y, function(x, y) cos(y)/(1 + x^2)) f es una matriz

cuadrada, con filas y columnas indexadas por x e y respectivamente, de valores de la función porque(y)/
2
(1 + x ).
oldpar < par(no.readonly = TRUE) par(pty="s")
Guarde los parámetros de trazado y establezca la región de trazado en "cuadrado".
contorno(x, y, f)
contorno(x, y, f, nniveles=15, agregar=VERDADERO)
Haz un mapa de contorno de f; agregue más líneas para obtener más detalles.
fa < (pies(f))/2
fa es la “parte asimétrica” de f. (t() es transpuesta).
contorno(x, y, fa, nniveles=15)

Haz un trazado de contorno, . . .
par(par
antiguo) . . . y restaurar los parámetros gráficos antiguos.
imagen(x, y, f)
imagen(x, y, fa)
Haga algunos trazados de imágenes de alta densidad (de los cuales puede obtener copias impresas si lo desea),
...
objetos(); rm(x, y, f, fa). . . y limpiar

antes de continuar.
R también puede hacer aritmética compleja.
th < seq(pi, pi, len=100) z <

exp(1i*th) 1i se usa
para el número complejo i.
par(pty="s")
trazado(z, tipo="l")
Trazar argumentos complejos significa trazar partes imaginarias versus partes reales. Esto debería ser
un círculo.
w < norma(100) + norma(100)*1i

Supongamos que queremos muestrear puntos dentro del círculo unitario. Un método sería tomar
números complejos con partes reales e imaginarias normales estándar. ..
w < ifelse(Mod(w) > 1, 1/w, w)

. . . y asignar cualquier fuera del círculo a su recíproco.
plot(w, xlim=c(1,1), ylim=c(1,1), pch="+",xlab="x", ylab="y") líneas(z) Todos los puntos

están dentro el círculo unitario, pero la distribución no es uniforme.
w < sqrt(runif(100))*exp(2*pi*runif(100)*1i) plot(w, xlim=c(1,1),

ylim=c(1,1), pch= "+", xlab="x", ylab="y") líneas(z) El segundo método utiliza la distribución
uniforme. Los puntos ahora deberían verse más
espaciados uniformemente sobre el disco.
rm(th, w, z)
Limpiar de nuevo.
q() Salga del programa R. Se le preguntará si desea guardar el espacio de trabajo de R y, para una sesión
exploratoria como esta, probablemente no desee guardarlo.
Apéndice B: Invocar R 85
Apéndice B Invocar R
Los usuarios de R en Windows u OS X deben leer primero la sección específica del sistema operativo, pero también se admite el uso
de la línea de comandos.
B.1 Invocar R desde la línea de comando

Cuando se trabaja en una línea de comando en UNIX o Windows, el comando 'R' se puede usar tanto para iniciar el
programa principal de R en el formulario
R [opciones] [<archivo de entrada] [>archivo de salida],
o, a través de la interfaz R CMD, como un contenedor para varias herramientas de R (por ejemplo, para procesar
archivos en formato de documentación de R o manipular paquetes complementarios) que no deben llamarse
"directamente".
En la línea de comandos de Windows, se prefiere Rterm.exe a R.
Debe asegurarse de que la variable de entorno TMPDIR no esté configurada o que apunte a un lugar válido para
crear archivos y directorios temporales.
La mayoría de las opciones controlan lo que sucede al principio y al final de una sesión de R. El mecanismo de
inicio es el siguiente (consulte también la ayuda en línea sobre el tema 'Inicio' para obtener más información y la
sección siguiente para obtener algunos detalles específicos de Windows).
• A menos que se proporcione noenviron, R busca archivos de usuario y de sitio para procesar y configurar
variables de entorno. El nombre del archivo del sitio es el que señala la variable de entorno R_ENVIRON; si
no está configurado, se utiliza R_HOME/etc/Renviron.site (si existe).
El archivo de usuario es aquel al que apunta la variable de entorno R_ENVIRON_USER si está configurada;
de lo contrario, se buscan los archivos .Renviron en el directorio actual o en el directorio de inicio del usuario
(en ese orden). Estos archivos deben contener líneas del formato 'nombre=valor'. (Consulte la ayuda ("Inicio")
para obtener una descripción precisa). Las variables que quizás desee configurar incluyen R_ PAPERSIZE (el
tamaño de papel predeterminado), R_PRINTCMD (el comando de impresión predeterminado) y R_LIBS
(especifica la lista de árboles de bibliotecas de R buscados para agregar en
paquetes). • Luego R busca el perfil de inicio de todo el sitio a menos que se haya proporcionado la opción de
línea de comando no sitefile. El nombre de este archivo se toma del valor de la variable de entorno
R_PROFILE. Si esa variable no está configurada, el valor predeterminado R_HOME/etc/Rprofile.site es
utilizado si existe.
• Luego, a menos que se haya proporcionado noinitfile, R busca un perfil de usuario y lo obtiene. El nombre de
este archivo se toma de la variable de entorno R_PROFILE_USER; si no está configurado, se busca un archivo
llamado .Rprofile en el directorio actual o en el directorio de inicio del usuario (en ese orden).
• También carga un espacio de trabajo guardado desde el archivo .RData en el directorio actual, si lo hay.
(a menos que se haya especificado norestore o norestoredata).
• Finalmente, si existe una función .First(), se ejecuta. Esta función (así como .Last() que se ejecuta al final de la
sesión de R) se puede definir en los perfiles de inicio apropiados o residir en .RData.
Además, existen opciones para controlar la memoria disponible para el proceso R (consulte la ayuda en línea
sobre el tema 'Memoria' para obtener más información). Normalmente, los usuarios no necesitarán usarlos a menos
que estén intentando limitar la cantidad de memoria utilizada por R.
R acepta las siguientes opciones de línea de comandos.
ayuda
h Imprima un breve mensaje de ayuda en la salida estándar y salga correctamente.
versión
Imprima la información de la versión en la salida estándar y salga correctamente.
encoding=enc
Especifique la codificación que se asumirá para la entrada desde la consola o la entrada estándar. Debe ser
una codificación conocida por iconv: consulte su página de ayuda. (También se acepta encoding enc). La
entrada se vuelve a codificar en la configuración regional en la que se ejecuta R y debe ser representable en la
codificación de este último (por lo que, por ejemplo, no se puede volver a codificar el texto griego en una
configuración regional francesa a menos que esa configuración regional use la codificación UTF8).
ROMA Imprima la ruta al “directorio de inicio” de R para la salida estándar y salga con éxito. Aparte del script de
shell del frontend y la página de manual, la instalación de R coloca todo (ejecutables, paquetes, etc.) en
este directorio.
ahorrar
noguardar
Controle si los conjuntos de datos deben guardarse o no al final de la sesión de R. Si no se proporciona

ninguno de los dos en una sesión interactiva, se le pregunta al usuario cuál es el comportamiento deseado
al finalizar la sesión con q(); en el uso no interactivo, uno de estos debe especificarse o implicarse en alguna
otra opción (ver más abajo).
sinentorno
No lea ningún archivo de usuario para configurar variables de entorno.
nositefile No lea el
perfil de todo el sitio al inicio.
noarchivoinit
No lea el perfil del usuario al inicio.
restaurar
sin restauración
norestaurardatos
Controle si las imágenes guardadas (archivo .RData en el directorio donde se inició R) deben restaurarse al
inicio o no. El valor predeterminado es restaurar. (norestore implica todas las opciones específicas de no
restore*).
norestorehistory Controla si
el archivo de historial (normalmente el archivo .Rhistory en el directorio donde se inició R, pero puede
configurarse mediante la variable de entorno R_HISTFILE) debe restaurarse al inicio o no. El valor
predeterminado es restaurar.
noRconsole
(Solo Windows) Evite cargar el archivo Rconsole al inicio.
vainilla
Combine nosave, noenviron, nositefile, noinitfile y no recovery. En Windows, esto también
incluye noRconsole.
f archivo
archivo=archivo
(no Rgui.exe) Tomar información del archivo: '' significa entrada estándar. Implica nosave a menos que
se haya configurado save. En un sistema Unix, se deben evitar los metacaracteres del shell en el archivo
(pero se permiten espacios).
e expresión (no
Rgui.exe) Utilice la expresión como línea de entrada. Se pueden usar una o más opciones e, pero no junto
con f o file. Implica nosave a menos que se haya configurado save. (Existe un límite de 10.000 bytes
en la longitud total de las expresiones utilizadas de esta manera. Las expresiones que contengan espacios
o metacaracteres de shell deberán ir entre comillas).
sin línea de lectura

(Solo UNIX) Desactive la edición de la línea de comandos mediante readline. Esto es útil cuando se ejecuta
R desde Emacs usando el paquete ESS (“Emacs Speaks Statistics”). Consulte el Apéndice C [El editor de
línea de comandos], página 92, para obtener más información. La edición de la línea de comandos está
habilitada para uso interactivo predeterminado (consulte interactive). Esta opción también afecta la
expansión de tilde: consulte la ayuda para path.expand.
minvsize=N
minizquierda=N
Solo para uso experto: establezca los tamaños de activación iniciales para la recolección de basura del montón
de vectores (en bytes) y de las celdas de contras (número), respectivamente. El sufijo 'M' especifica megabytes
o millones de celdas respectivamente. Los valores predeterminados son 6 Mb y 350 k respectivamente y
también se pueden configurar mediante las variables de entorno R_NSIZE y R_VSIZE.
maxppsize=N
Especifique el tamaño máximo de la pila de protección del puntero como N ubicaciones. El valor
predeterminado es 10000, pero se puede aumentar para permitir realizar cálculos grandes y complicados.
Actualmente el valor máximo aceptado es 100000.
maxmemsize=N
(Solo Windows) Especifique un límite para la cantidad de memoria que se utilizará tanto para los objetos R
como para las áreas de trabajo. Esto está configurado de forma predeterminada en la menor cantidad de
, 32 Mb y el máximo permitido en
RAM física en la máquina y para R de 32 bits, 1,5 Gb1 y debe estar entre
esa versión de Windows.
tranquilo
silencioso
q No imprima los mensajes iniciales de copyright y de bienvenida.
slave Haz que R funcione lo más silenciosamente posible. Esta opción está destinada a admitir programas que utilizan R
para calcular sus resultados. Implica tranquilo y nosalvar.
interactivo
(Solo UNIX) Afirme que R realmente se está ejecutando de forma interactiva incluso si la entrada ha sido
redirigida: utilícela si la entrada proviene de un FIFO o tubería y se alimenta desde un programa interactivo.
(El valor predeterminado es deducir que R se ejecuta de forma interactiva si y solo si stdin está conectado a
una terminal o pty). El uso de e, f o file afirma un uso no interactivo incluso si se proporciona interactive.
Tenga en cuenta que esto no activa la edición de la línea de comandos.
ess (Solo Windows) Configure Rterm para su uso en modo R inferior en ESS, incluido el uso interactivo (sin el
editor de línea de comandos) y sin almacenamiento en búfer de stdout.
verboso
Imprima más información sobre el progreso y, en particular, establezca la opción detallada de R en
VERDADERO. El código R utiliza esta opción para controlar la impresión de mensajes de diagnóstico.
debugger=nombre d
nombre (solo UNIX) Ejecute R a través del nombre del depurador. Para la mayoría de los depuradores (las excepciones son
valgrind y las versiones recientes de gdb), se ignoran las opciones de línea de comando adicionales y, en su
lugar, se deben proporcionar al iniciar el ejecutable R desde dentro del depurador.
gui=tipo g
tipo (solo UNIX) Utilice el tipo como interfaz gráfica de usuario (tenga en cuenta que esto también incluye gráficos
interactivos). Actualmente, los valores posibles para el tipo son 'X11' (el valor predeterminado) y,
1
2,5 Gb en versiones de Windows que admiten 3 Gb por proceso y tienen el soporte habilitado: consulte rwFAQ Q2.9; 3,5
Gb en la mayoría de las versiones de 64 bits de Windows.
siempre que esté disponible el soporte 'Tcl/Tk', 'Tk'. (Para compatibilidad con versiones anteriores, 'x11' y
Se aceptan 'tk'.)
arco=nombre
(Solo UNIX) Ejecute la subarquitectura especificada.
argumentos Esta bandera no hace nada excepto hacer que se omita el resto de la línea de comando:
esto puede ser útil para recuperar valores con commandArgs(TRUE).
Tenga en cuenta que la entrada y la salida se pueden redirigir de la forma habitual (usando '<' y '>'), pero el
Aún se aplica el límite de longitud de línea de 4095 bytes. Se envían mensajes de advertencia y error al error.
canal (stderr).
El comando R CMD permite la invocación de varias herramientas que son útiles en conjunto
con R, pero no pretende ser llamado "directamente". La forma general es
Argumentos del comando R CMD
donde comando es el nombre de la herramienta y argumenta los argumentos que se le pasan.
Actualmente, las siguientes herramientas están disponibles.
LOTE Ejecute R en modo por lotes. Ejecuta R restore save con posiblemente más opciones (ver
?LOTE).
COMPILAR (solo UNIX) Compile C, C++, Fortran. . . archivos para usar con R.
SHLIB Cree una biblioteca compartida para carga dinámica.
INSTALAR Instalar paquetes complementarios.
QUITAR Quitar paquetes complementarios.
construir Cree (es decir, empaquete) paquetes complementarios.
controlar Consulte los paquetes complementarios.
ENLACE (Solo UNIX) Frontend para crear programas ejecutables.
Rprof Postprocesar archivos de perfiles R.
Rdconv
Rd2txt Convierta el formato Rd a varios otros formatos, incluidos HTML, LATEX, texto sin formato,
y extrayendo los ejemplos. Rd2txt se puede utilizar como abreviatura de Rd2conv t txt.
Rd2pdf Convierta el formato Rd a PDF.
Stangle Extrae el código S/R de Sweave u otra documentación de viñeta
tejer Process Sweave u otra documentación de viñeta
Riff Salida Diff R ignorando encabezados, etc.
configuración Obtener información de configuración
javareconf
(Solo Unix) Actualizar las variables de configuración de Java
etiquetas (Solo Unix) Cree archivos de etiquetas estilo Emacs a partir de archivos C, R y Rd
abierto (Solo Windows) Abrir un archivo a través de las asociaciones de archivos de Windows
texificar (Solo Windows) Procesar archivos (La)TeX con archivos de estilo de R
Usar
Comando R CMD ayuda

para obtener información de uso de cada una de las herramientas accesibles a través de la interfaz R CMD.
Además, puede usar las opciones arch=, noenviron, noinitfile, nosite file y vanilla entre R y CMD: estas
afectan cualquier proceso de R ejecutado por las herramientas. . (Aquí vanilla es equivalente a noenviron nositefile
noinitfile.) Sin embargo, tenga en cuenta que R CMD no utiliza por sí solo ningún archivo de inicio de R (en particular, ni el
usuario ni archivos Renviron del sitio), y todos los procesos R ejecutados por estas herramientas (excepto BATCH) usan
norestore. La mayoría usa vanilla y, por lo tanto, no invoca archivos de inicio de R: las excepciones actuales son INSTALL,
REMOVE, Sweave y SHLIB (que usa nositefile noinitfile).
R CMD cmd
argumentos para cualquier otro cmd ejecutable en la ruta o dado por una ruta de archivo absoluta: esto es útil para tener el
mismo entorno que R o los comandos específicos que se ejecutan, por ejemplo, para ejecutar ldd o pdflatex. En Windows,
cmd puede ser un archivo ejecutable o por lotes, o si tiene la extensión .sh o .pl, se llama al intérprete apropiado (si está
disponible) para ejecutarlo.
B.2 Invocar R en Windows Hay dos formas de ejecutar R en
Windows. Dentro de una ventana de terminal (por ejemplo, cmd.exe o un shell más capaz), se pueden usar los métodos
descritos en la sección anterior, invocando mediante R.exe o más directamente mediante Rterm.exe. Para uso interactivo,
existe una GUI basada en consola (Rgui.exe).
El procedimiento de inicio en Windows es muy similar al de UNIX, pero es necesario aclarar las referencias al 'directorio
de inicio', ya que no siempre está definido en Windows. Si se define la variable de entorno R_USER, eso proporciona el
directorio de inicio. A continuación, si se define la variable de entorno HOME, eso proporciona el directorio de inicio.
Después de esas dos configuraciones controlables por el usuario, R intenta encontrar directorios de inicio definidos por el
sistema. Primero intenta utilizar el directorio "personal" de Windows (normalmente C:\Documentos y configuraciones\nombre
de usuario\Mis documentos en Windows XP). Si eso falla, y las variables de entorno HOMEDRIVE y HOMEPATH están
definidas (y normalmente lo están), estas definen el directorio de inicio. En su defecto, el directorio de inicio se considera el
directorio de inicio.
Debe asegurarse de que las variables de entorno TMPDIR, TMP y TEMP sean
no configurado o uno de ellos apunta a un lugar válido para crear archivos y directorios temporales.
Las variables de entorno se pueden proporcionar como pares 'nombre=valor' en la línea de comando.
Si hay un argumento que termina en .RData (en cualquier caso), se interpreta como la ruta al espacio de trabajo que se
va a restaurar: implica restore y establece el directorio de trabajo en el padre del archivo nombrado. (Este mecanismo se
utiliza para arrastrar y soltar y asociar archivos con RGui.exe, pero también funciona para Rterm.exe. Si el archivo nombrado
no existe, establece el directorio de trabajo si el directorio principal existe).
Las siguientes opciones adicionales de línea de comandos están disponibles al invocar RGui.exe.
mdi
IDE
nomdi Controla si Rgui funcionará como un programa MDI (con múltiples ventanas secundarias dentro de una ventana
principal) o una aplicación SDI (con múltiples ventanas de nivel superior para la consola, gráficos y
buscapersonas). La configuración de la línea de comandos anula la configuración del archivo Rconsole del
usuario.
debug Habilite el elemento de menú "Pasar al depurador" en Rgui y active una pausa en el depurador durante el
procesamiento de la línea de comandos.
En Windows con R CMD también puede especificar su propio archivo .bat, .exe, .sh o .pl. Se ejecutará bajo el intérprete
apropiado (Perl para .pl) con varias variables de entorno configuradas adecuadamente, incluidas R_HOME, R_OSTYPE,
PATH, BSTINPUTS y TEXINPUTS. Por ejemplo, si ya tiene latex.exe en su ruta, entonces
R CMD latex.exe midoc

ejecutará LATEX en mydoc.tex, con la ruta a las macros share/texmf de R adjuntas a TEXINPUTS.
(Desafortunadamente, esto no ayuda con la compilación MiKTeX de LATEX, pero R CMD texify mydoc funcionará
en ese caso).
B.3 Invocar R en OS X
Hay dos formas de ejecutar R en OS X. Dentro de una ventana Terminal.app al invocar R, se aplican los métodos
descritos en la primera subsección. También hay una GUI basada en consola (R.app) que de forma predeterminada
se instala en la carpeta Aplicaciones de su sistema. Es una aplicación OS X estándar en la que se puede hacer
doble clic.
El procedimiento de inicio en OS X es muy similar al de UNIX, pero R.app no utiliza argumentos de línea de
comandos. El 'directorio de inicio' es el que está dentro de R.framework, pero el directorio de inicio y el directorio
de trabajo actual se configuran como el directorio de inicio del usuario a menos que se proporcione un directorio
de inicio diferente en la ventana Preferencias accesible desde la GUI.
B.4 Secuencias de comandos con R

Si solo desea ejecutar un archivo foo.R de comandos R, la forma recomendada es usar R CMD BATCH foo.R. Si desea ejecutar
esto en segundo plano o como un trabajo por lotes, utilice funciones específicas del sistema operativo para hacerlo: por
ejemplo, en la mayoría de los shells en sistemas operativos similares a Unix, R CMD BATCH foo.R y ejecuta un trabajo en
segundo plano.
Puede pasar parámetros a scripts mediante argumentos adicionales en la línea de comando: para
ejemplo (donde las comillas exactas necesarias dependerán del shell en uso)
R CMD BATCH "args arg1 arg2" foo.R & pasará
argumentos a un script que se puede recuperar como un vector de caracteres mediante
argumentos < comandoArgs(VERDADERO)
Esto se simplifica gracias al frontend alternativo Rscript, que puede ser invocado por
Rscript foo.R arg1 arg2
y esto también se puede usar para escribir archivos de script ejecutables como (al menos en sistemas similares a
Unix y en algunos shells
de Windows) #! /ruta/a/
Rscript args < commandArgs(VERDADERO)
...
q(estado=<código de estado de salida>)
Si esto se ingresa en un archivo de texto runfoo y se hace ejecutable (mediante chmod 755 runfoo), se puede
invocar para diferentes argumentos mediante
runfoo arg1 arg2. Para
obtener más opciones, consulte la ayuda ("Rscript"). Esto escribe la salida de R en stdout y stderr, y esto se puede
redirigir de la forma habitual para el shell que ejecuta el comando.
Si no desea codificar la ruta a Rscript pero la tiene en su ruta (lo que normalmente es el caso para un R
instalado excepto en Windows, pero, por ejemplo, los usuarios de OS X pueden necesitar agregar /usr/local/bin a
su ruta) , usar #! /usr/bin/env Rscript
...
Al menos en Bourne y bash shells, el #! El mecanismo no permite argumentos adicionales como #! /usr/bin/env
Rscript vainilla.
Una cosa a considerar es a qué se refiere stdin(). Es común escribir scripts R con segmentos como
química < escaneo (n = 24)

2,90 3,10 3,40 3,40 3,70 3,70 2,80 2,50 2,40 2,40 2,70 2,20
5,28 3,37 3,03 3,03 28,95 3,77 3,40 2,20 3,50 3,60 3,70 3,70
y stdin() se refiere al archivo de script para permitir dicho uso tradicional. Si desea hacer referencia a la entrada estándar
del proceso, utilice "stdin" como conexión de archivo, por ejemplo, scan("stdin", ...).
Otra forma de escribir archivos de script ejecutables (sugerida por Fran¸cois Pinard) es utilizar un aquí
documento como
#!/bin/sh [las
variables de entorno se pueden configurar aquí]
R slave [otras opciones] <<EOF
El programa R va aquí...
EOF
pero aquí stdin() se refiere a la fuente del programa y "stdin" no será utilizable.
Se pueden pasar scripts cortos a Rscript en la línea de comandos mediante el indicador e. (No se aceptan guiones
vacíos).
Tenga en cuenta que en un sistema Unix, el nombre del archivo de entrada (como foo.R) no debe contener espacios ni
metacaracteres del shell.
Apéndice C: El editor de línea de comandos 92
Apéndice C El editor de línea de comandos
C.1 Preliminares
Cuando la biblioteca readline de GNU está disponible en el momento en que R se configura para la compilación en
UNIX, se utiliza un editor de línea de comandos incorporado que permite recuperar, editar y volver a enviar comandos
anteriores. Tenga en cuenta que existen otras versiones de readline y pueden ser utilizadas por el editor de línea de
comandos incorporado: esto solía suceder en OS X.
Se puede desactivar (útil para usar con ESS1 ) usando la opción de inicio noreadline.
Las versiones de Windows de R tienen una edición de línea de comandos algo más simple: consulte 'Consola' en el
menú 'Ayuda' de la GUI y el archivo README.Rterm para editar la línea de comandos en Rterm.exe.
Cuando se utiliza R con capacidades de línea de lectura, las funciones que se describen a continuación están disponibles, así como
como otros (probablemente) documentados en man readline o info readline en su sistema.
Muchos de ellos utilizan caracteres de control o meta. Los caracteres de control, como Controlm, se obtienen
manteniendo presionada la tecla CTRL mientras presiona la tecla m, y se escriben como Cm a continuación.
Los metacaracteres, como Metab, se escriben manteniendo presionado META2 y presionando b, y se escriben como
Mb a continuación. Si su terminal no tiene una tecla META habilitada, aún puede escribir caracteres Meta usando
secuencias de dos caracteres que comiencen con ESC. Por lo tanto, para ingresar Mb, puede escribir ESCb. Las
secuencias de caracteres ESC también están permitidas en terminales con Meta claves reales. Tenga en cuenta que
las mayúsculas y minúsculas son importantes para los caracteres Meta.
C.2 Acciones de edición

El programa R mantiene un historial de las líneas de comando que usted escribe, incluidas las líneas erróneas, y los
comandos en su historial se pueden recuperar, cambiar si es necesario y volver a enviar como comandos nuevos. En la
edición de línea de comandos al estilo de Emacs, cualquier escritura directa que realice durante esta fase de edición
hace que los caracteres se inserten en el comando que está editando, desplazando cualquier carácter a la derecha del
cursor. En el modo vi, el modo de inserción de caracteres se inicia con Mi o Ma, los caracteres se escriben y el modo de
inserción finaliza escribiendo otro ESC. (El valor predeterminado es el estilo Emacs, y aquí solo se describe eso: para el
modo vi, consulte la documentación de readline).
Al presionar el comando RET en cualquier momento, se vuelve a enviar el comando.
Otras acciones de edición se resumen en la siguiente tabla.
C.3 Resumen del editor de línea de comandos

Recuperación de comandos y movimiento vertical.
CP Ir al comando anterior (hacia atrás en el historial).
cn Pasa al siguiente comando (hacia adelante en el historial).
Cr text Encuentra el último comando que contiene la cadena de texto.
En la mayoría de los terminales, también puedes utilizar las teclas de flecha arriba y abajo en lugar de Cp y Cn,
respectivamente.
1
El paquete 'Emacs Speaks Statistics'; consulte la URL http://ESS.Rproject.org En el
2
teclado de una PC, esta suele ser la tecla Alt, ocasionalmente la tecla 'Windows'. En un teclado Mac normalmente no
hay ninguna tecla meta disponible.
Apéndice C: El editor de línea de comandos 93
Movimiento horizontal del cursor

Eso Vaya al principio del comando.
Este Ve al final de la línea.
megabyte Retroceder una palabra.
mf Avanza una palabra.
cb Retrocede un carácter.
cf Avanza un carácter.
En la mayoría de los terminales, también puedes usar las teclas de flecha izquierda y derecha en lugar de Cb y Cf,
respectivamente.
Edición y reenvío
texto Insertar texto en el cursor.
Cf texto Añade texto después del cursor.
DEL Elimina el carácter anterior (a la izquierda del cursor).
Cd Elimina el carácter debajo del cursor.
Maryland Elimine el resto de la palabra debajo del cursor y “guárdela”.
ck Elimine desde el cursor hasta el final del comando y “guárdelo”.
cy Inserte (tire) el último texto "guardado" aquí.
Connecticut
Transponga el carácter debajo del cursor con el siguiente.
ml Cambia el resto de la palabra a minúsculas.
Mc Cambia el resto de la palabra a mayúsculas.
BIEN Vuelva a enviar el comando a R.
El RET final finaliza la secuencia de edición de la línea de comando.

Las combinaciones de teclas de readline se pueden personalizar de la forma habitual a través de un archivo ~/.inputrc. Estos
Las personalizaciones se pueden condicionar a la aplicación R, es decir, incluyendo una sección como
$si R
"\Cxd": "q('no')\n"
$endif
Apéndice D: Función e índice de variable 94
Apéndice D Función y índice de variable
! ?? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
!. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
^
!= . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
^. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
%
%*%. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . |
22%o%. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
|. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
|| . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
&
~
&. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
9&&. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40 ~
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
*
A
*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8 ablino. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
as. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
+ agregar1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
ánova. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54, 55
+. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8 aov. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
aperm. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
matriz. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
como.marco.de.datos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8 como.vector. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
adjuntar. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
. atributo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
atributos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55 Ávas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
.Primero. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ejes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67
48 .Último . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
B
/ diagrama de caja. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
/. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8 coches familiares. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
brutos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
:
:. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . C
8 :: . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . C. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7, 10, 24, 27
78 ::: . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78 cvincular. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
coef. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
coeficientes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
< contorno. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . sesenta y cinco
<. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . contrastes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
<< 9.............................................. coplot. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64
47 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9 <= porque . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8 productos
cruzados. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19, 22
= corte. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
25ºC. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
== . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
D
> datos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
>. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . marco de datos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
>= 9 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9 densidad. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
det. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
desprenderse. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
? determinante. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23 lista de
?. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4 desarrolladores. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
dev.siguiente. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75 niveles. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
dev.apagado. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75 líneas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
dev.anterior. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75 conjunto lista . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
de desarrollo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75 lm. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
desviación. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54 veces. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
diag. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22 locador. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68
tenue. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18 pérdidas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
diagrama de puntos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65 registro . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
gota1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56 litros. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
lsfit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
Y
METRO
ECDF. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
editar. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32 Marte. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
propios. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23 máx. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
más. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40 significa. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
errores. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55 métodos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
ejemplo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4 mío . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
exp. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8 moda. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
F norte
factor. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . dieciséis Yaya. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9

FALSO . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9 ESO. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
cinconum. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34 ncol. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
para . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40 siguiente. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
fórmula. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54 nlm. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59, 60, 61
función . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42 níme. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
F. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9 nlminb. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
Ahora. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
GRAMO
llegar a donde sea . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49 oh

método getS3. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49 optimo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
gramos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57 orden. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
ordenado. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
exterior. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
h
ayuda . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
PAG
ayuda.búsqueda . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
ayuda.inicio. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4 pares. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64
hist. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34, 64 par. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68
pasta. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
10pdf. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74
I perspicacia. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65
identificar . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68 parcela. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54, 63
si. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40 en caso pmáx. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8 p.
contrario. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40 m. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
imagen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65 png. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74
es.na . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9 puntos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
es en. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10 polígonos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
posdata. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74
predicen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
j
imprimir. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
jpeg. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74 prod. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
k Q
ks.prueba. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
línea qq . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35, 64
qqnorm. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35, 64 trama
l qq. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64
qr. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
leyenda. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66 de
cuarzo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74
longitud. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8, 13
R t
rango . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8 t . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
vueltas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24 t.prueba. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
leer.tabla. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30 mesa. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20, 25
bronceado. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
repeticiones. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
repetir. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41 toque. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
texto. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
residen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
título. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67
residuales. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
árbol . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
rlm. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
T. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
habitaciones. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
VERDADERO . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
S EN
escanear. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31 sin clase. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
Dakota del Sur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17 actualización. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
buscar. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
secuencia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
8 prueba.shapiro. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
EN
sin . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
var. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8, 17 prueba
hundir . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5 var. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
resolver . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22 vcov. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
clasificar . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8 vectores. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
fuente . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
dividir . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40 pies
cuadrados. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
EN
tallo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34 mientras . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
prueba.wilcox. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
paso . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54, 56
suma. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
ventanas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74
resumen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34, 54
svd. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
X
X11. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74
Apéndice E: Índice de conceptos 97
Apéndice E Índice de conceptos
A k
Acceder a conjuntos de datos integrados. . . . . . . . . . . . . . . . . . . . . . . . Prueba de KolmogorovSmirnov. . . . . . . . . . . . . . . . . . . . . . . . 36
31 Modelos aditivos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
Análisis de varianza . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
Funciones y operadores aritméticos. . . . . . . . . . . . . . . . 7 l
matrices. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18 Ajuste de mínimos cuadrados. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Tarea . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7 23 ecuaciones lineales. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
atributos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13 modelos lineales. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
Listas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
Regresiones locales aproximadas. . . . . . . . . . . . . . . . . . 61 Bucles y
B ejecución condicional. . . . . . . . . . . . . . . . . . 40
Operadores binarios. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
Diagramas de caja. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
METRO
Matrices. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
C Multiplicación de matrices. . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
Vectores de caracteres. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10 Máxima verosimilitud . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60 valores
Clases. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14, 49 faltantes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9 modelos

mixtos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
Concatenación de listas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
Contrastes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
Declaraciones de control. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
norte
GRÚA. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77
Personalización del entorno . . . . . . . . . . . . . . . . . . . . 48 Argumentos nombrados. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
Espacio de nombres. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
78 Mínimos cuadrados no lineales. . . . . . . . . . . . . . . . . . . . . . . . . . . 59
D
Marcos de datos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
oh
Valores predeterminados . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Orientación a objetos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
43 Estimación de densidad. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
Objetos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
Determinantes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
Pruebas de una y dos muestras. . . . . . . . . . . . . . . . . . . . . . . 36
Desviando entrada y salida. . . . . . . . . . . . . . . . . . . . . . . . 5 Gráficos
factores ordenados. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16, 53
dinámicos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76
Productos externos de matrices. . . . . . . . . . . . . . . . . . . . . . . . . 21
Y PAG
Valores propios y vectores propios . . . . . . . . . . . . . . . . . . . . . 23 CDF Paquetes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2, 77

empíricos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35 Distribuciones de probabilidad. . . . . . . . . . . . . . . . . . . . . . . . . 33
F
Factores. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16, 53 Descomposición Q QR. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
familias. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57 Gráficos cuantilcuantil. . . . . . . . . . . . . . . . . . . . . . . . . . . 35
Fórmulas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
R
GRAMO
Lectura de datos de archivos. . . . . . . . . . . . . . . . . . . . . . . . . . . 30
Modelos lineales generalizados. . . . . . . . . . . . . . . . . . . . . . . . 56
Regla de reciclaje . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7, 20
Transpuesta generalizada de una matriz. . . . . . . . . . . . . . . . 21 Secuencias regulares. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
Funciones genéricas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49 Eliminación de objetos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
Controladores de dispositivos gráficos. . . . . . . . . . . . . . . . . . . . . . . . . . . Regresión robusta. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
74 Parámetros gráficos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68
expresiones agrupadas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
S
Alcance . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
I Ruta de búsqueda . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Indexación de y por matrices. . . . . . . . . . . . . . . . . . . . . . . . 18 29 Prueba de ShapiroWilk . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
vectores de indexación. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10 36 Descomposición de valores singulares. . . . . . . . . . . . . . . . . . . . .
23 Modelos estadísticos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
Apéndice E: Índice de conceptos 98
Prueba t de Student. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37 EN
Vectores. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
t
Tabulación. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
Modelos basados en árboles. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61 EN
Prueba de Wilcoxon. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
U
Espacio de trabajo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Actualización de modelos equipados. . . . . . . . . . . . . . . . . . . . . . . . . . . 55 5 Funciones de escritura. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
Apéndice F: Referencias 99
Apéndice F Referencias
DM Bates y DG Watts (1988), Análisis de regresión no lineal y sus aplicaciones. John Wiley & Sons,
Nueva York.
Richard A. Becker, John M. Chambers y Allan R. Wilks (1988), El nuevo lenguaje S. Chapman & Hall,
Nueva York. Este libro a menudo se llama el "Libro Azul".
John M. Chambers y Trevor J. Hastie eds. (1992), Modelos estadísticos en S. Chapman & Hall, Nueva
York. También se le llama “Libro Blanco”.
John M. Chambers (1998) Programación con datos. Springer, Nueva York. También se le llama el “Libro
Verde”.
AC Davison y DV Hinkley (1997), Métodos Bootstrap y sus aplicaciones, Cambridge University Press.
Annette J. Dobson (1990), Introducción a los modelos lineales generalizados, Chapman y Hall,
Londres.
Peter McCullagh y John A. Nelder (1989), Modelos lineales generalizados. Segunda edición, Chapman
y Hall, Londres.
John A. Rice (1995), Estadística matemática y análisis de datos. Segunda edicion. Prensa de Duxbury,
Belmont, CA.
SD Silvey (1970), Inferencia estadística. Pingüino, Londres.

Una Introducción A R

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Una Introducción A R

Cargado por

Copyright:

Formatos disponibles

Una introducción a R

Notas sobre R: Un entorno de programación para análisis de datos y gráficos

1 Introducción y preliminares . . . ............................2

2 manipulaciones simples; números y vectores. . . ..............7

3 Objetos, sus modos y atributos. . . . . . . . . . . . . . . . . . . . . . . . 13

4 Factores ordenados y desordenados. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . dieciséis

5.7.2 Ecuaciones lineales e inversión. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22

6 Listas y marcos de datos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26

7 Lectura de datos de archivos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30

9 Agrupación, bucles y ejecución condicional. . . . . . . . . . . . . . . . . 40

10 Escribir tus propias funciones. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42

14 instalaciones del sistema operativo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79

Apéndice AA sesión de muestra. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82

Apéndice C El editor de línea de comandos. . . . . . . . . . . . . . . . . . . . . . . 92

Apéndice D Función e índice de variable. . . . . . . . . . . . . . . . . . . . 94

Apéndice E Índice de conceptos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97

Sugerencias para el lector La mayoría de

y manejo de datos, • un conjunto de operadores para cálculos en

matrices, en particular matrices, • una colección grande, coherente e integrada de herramientas

en la computadora o en el disco duro

1.2 Software y documentación relacionados

1.4 R y el sistema de ventanas.

1.5 Usando R interactivamente

2. Inicie el programa R con el comando $R

3. En este punto se pueden emitir comandos R (ver más adelante).

Otras sesiones de R son sencillas.

2. Utilice el programa R y finalice con el comando q() al final de la sesión.

1.6 Una sesión introductoria

1.7 Obtener ayuda con funciones y características

> ayuda (resolver)

> help.start() que

Pruebe ?help.search para obtener detalles y más ejemplos.

Comandos 1.8 R, distinción entre mayúsculas y minúsculas, etc.

Capítulo 1: Introducción y preliminares 5

1.9 Recuperación y corrección de comandos anteriores

desviará toda la salida posterior de la consola a un archivo externo, record.lis. El comando

lo restaura a la consola una vez más.

1.11 Permanencia de datos y eliminación de objetos

Capítulo 1: Introducción y preliminares 6

> rm(x, y, z, tinta, basura, temperatura, foo, barra)

Capítulo 2: Manipulaciones simples; numeros y vectores 7

2 manipulaciones simples; numeros y vectores

2.1 Vectores y asignación

La asignación adicional > y

2.2 Aritmética vectorial

Capítulo 2: Manipulaciones simples; numeros y vectores 8

2.3 Generando secuencias regulares

La construcción 30:1 se puede utilizar para generar una secuencia al revés.

Capítulo 2: Manipulaciones simples; numeros y vectores 9

> s4 <­ seq(longitud=51, desde=­5, por=.2)

2.4 Vectores lógicos Además de

2.5 Valores faltantes

Capítulo 2: Manipulaciones simples; numeros y vectores 10

> Inf ­ Inf

2.6 Vectores de caracteres

2.7 vectores índice; seleccionar y modificar subconjuntos de un conjunto de datos

Capítulo 2: Manipulaciones simples; numeros y vectores 11

> y <­ x[­(1:5)] da y

Por ejemplo >

reemplaza cualquier valor faltante en x por ceros y > y[y

> y <­ abs(y)

2.8 Otros tipos de objetos Los vectores son el

Capítulo 2: Manipulaciones simples; numeros y vectores 12

> s4 < seq(longitud=51, desde=5, por=.2)

> Inf Inf

> y < x[(1:5)] da y

> y < abs(y)

> incmeans < tapply(ingresos, estado, media) dando un vector

Un vector de dimensión es un vector de números enteros no negativos. Si su longitud es k entonces la matriz es k

> tenue(z) < c(3,5,100)

> N < tabla(bloques, variedades)

> Z < matriz(vector_datos, vector_dim)

> Z < matriz(h, tenue=c(3,4,2))

>Z<h; tenue(Z) < c(3,4,2)

> Z < matriz(0, c(3,4,2))

> D < 2AB + C + 1

> ab < a %o% b

> f < función(x, y) cos(y)/(1 + x^2) > z < exterior(x, y,

lineales es la inversa de la multiplicación de matrices. Cuando después > b < A %*% x

> evaluaciones < valores propios(Sm)$

> evaluaciones < eigen(Sm, solo.valores = VERDADERO)$valores

> Xplus < qr(X) > b <

> X < cbind(arg_1, arg_2, arg_3, ...)

> cosa < c(X)