Una Introduccion A R

Una Introducción a R.
Notas en R: Un Entorno de Programación para Análisis de Datos y Gráfico.

Versión 3.6.1 (2019-07-05)
W. N. Venables, D. M. Smith y
el R Equipo de Núcleo
Este manual es para R, versión 3.6.1 (2019-07-05).
Copyright 1990 W. N. Venables
§
c 1992 W. N. Venables & D. M.
Copyright Smith 1997 R. Señor & R. Ihaka
§
c 1997, 1998 M. Maechler
Copyright 1999–2018 R Equipo de Núcleo
§
c
Copyright
§
c
Copyright
§
c
El permiso está concedido para hacer y distribuir verbatim las copias de este
manual proporcionaron el aviso de copyright y este aviso de permiso están
preservados encima todas las copias.
El permiso está concedido para copiar y distribuir modificó versiones de este
manual bajo las condiciones para verbatim copiando, proporcionados que el
enteros resultando el trabajo derivado está distribuido bajo los plazos de un
aviso de permiso idéntico a este un.
El permiso está concedido para copiar y distribuir traducciones de este
manual a un- otra lengua, bajo el por encima de condiciones para modificó
versiones, exceptúa que este aviso de permiso puede ser declarado en una
traducción aprobada por el R Equipo de Núcleo.
i
Mesa de Contenidos
Prefacio ................................................................................................. 1
1 Introducción y preliminaries ...................................................... 2

1.1 El R entorno ............................................................................................................. 2
1.2 Documentación y software relacionados ............................................................... 2
1.3 R Y estadística ....................................................................................................... 2
1.4 R Y el sistema de ventana ....................................................................................... 3
1.5 Utilizando R interactivamente ................................................................................. 3
1.6 Una sesión introductoria .......................................................................................... 4
1.7 Consiguiendo ayuda con funciones y presenta ...................................................... 4
1.8 R Órdenes, sensibilidad de caso, etc. ....................................................................... 4
1.9 Recuerda y corrección de órdenes anteriores ............................................................. 5
1.10 Ejecutando órdenes de o desviando producción a un archivo ............................ 5
1.11 Dato permanency y sacando objetos .................................................................... 5
2 Manipulaciones sencillas; números y vectores ........................ 7

2.1 Vectores y asignación .............................................................................................. 7
2.2 Aritmética de vector ................................................................................................. 7
2.3 Generando secuencias regulares .................................................................................. 8
2.4 Vectores lógicos ............................................................................................................ 9
2.5 Valores desaparecidos ................................................................................................... 9
2.6 Vectores de carácter .............................................................................................. 10
2.7 Vectores de índice; seleccionando y modificando subconjuntos de un conjunto de dato 10
2.8 Otros tipos de objetos ........................................................................................... 11
3 Objetos, sus modos y atribuye ............................................... 13

3.1 Atributos intrínsecos: modo y longitud ............................................................... 13
3.2 Cambiando la longitud de un objeto .................................................................... 14
3.3 Consiguiendo y poniendo atributos ................................................................. 14
3.4 La clase de un objeto ............................................................................................ 14
4 Ordenado y unordered factores ............................................... 16

4.1 Un ejemplo concreto ................................................................................................... 16
4.2 La función tapply() y ragged variedades ............................................................... 16
4.3 Ordenó factores ...................................................................................................... 17
5 Variedades y matrices ............................................................... 18

5.1 Variedades ................................................................................................................... 18
5.2 Indexación de variedad. Incisos de una variedad .................................................... 18
5.3 Matrices de índice....................................................................................................... 19
5.4 La variedad() función ....................................................................................................... 20
5.4.1 Variedad y vector mixtos aritmética. La regla de reciclaje ......................... 20
5.5 El producto exterior de dos variedades ................................................................ 21
5.6 Generalizado transpose de una variedad .................................................................. 21
5.7 Instalaciones matriciales ............................................................................................. 22
5.7.1 Multiplicación matricial ................................................................................. 22
ii
5.7.2 Ecuaciones lineales e inversion .......................................................................... 22
5.7.3 Eigenvalues Y eigenvectors ............................................................................... 23
5.7.4 Descomposición de valor singular y determinantes ......................................... 23
5.7.5 Menos cuadra caber y el QR descomposición ............................................... 23
5.8 Formando partitioned matrices, cbind() y rbind() ....................... 24
5.9 La función de concatenación, c(), con variedades ................................................. 24
5.10 Mesas de frecuencia de factores .............................................................................. 25
6 Las listas y el dato enmarca ...................................................... 26

6.1 Listas ............................................................................................................................ 26
6.2 Construyendo y modificando listas ...................................................................... 27
6.2.1 Concatenando listas ........................................................................................ 27
6.3 El dato enmarca ........................................................................................................... 27
6.3.1 Haciendo el dato enmarca ................................................................................... 27
6.3.2 Sujeta() y detach() ............................................ 28
6.3.3 Trabajando con los datos enmarca ..................................................................... 28
6.3.4 Sujetando listas arbitrarias ......................................................................... 28
6.3.5 Dirigiendo el camino de búsqueda ................................................................ 29
7 Leyendo dato de archivos ......................................................... 30

7.1 El leído.Mesa() función............................................................................................... 30
7.2 El escáner() función .................................................................................................... 31
7.3 Accediendo builtin datasets ................................................................................... 31
7.3.1 Cargando dato de otro R paquetes ........................................................................ 31
7.4 Editando dato ......................................................................................................... 32
8 Distribuciones de probabilidad ................................................ 33

8.1 R Como puesto de mesas estadísticas .................................................................. 33
8.2 Examinando la distribución de un conjunto de datos .......................................... 34
8.3 Uno- y dos-la muestra prueba................................................................................ 36
9 Agrupación, bucles y ejecución condicional ......................... 40

9.1 Agrupó expresiones ..................................................................................................... 40
9.2 Declaraciones de control ....................................................................................... 40
9.2.1 Ejecución condicional: si declaraciones .......................................................... 40
9.2.2 Ejecución repetitiva: para bucles, repite y mientras ................. 40
10 Escribiendo vuestras funciones propias ................................. 42

10.1 Ejemplos sencillos ..................................................................................................... 42
10.2 Definiendo operadores binarios nuevos ................................................................... 43
10.3 Nombró argumentos y defaults ........................................................................... 43
10.4 El ‘...' argument ................................................................................................................ 44
10.5 Asignaciones dentro de funciones ........................................................................... 44
10.6 Más adelantó ejemplos .............................................................................................. 44
10.6.1 Factores de eficacia en bloque diseña .............................................................. 44
10.6.2 Cayendo todos los nombres en una variedad imprimida ............................ 45
10.6.3 Integración numérica recursiva ......................................................................... 45
10.7 Alcance ............................................................................................................................ 46
10.8 Personalizando el entorno .................................................................................... 48
10.9 Clases, objeto y funciones genéricos orientación ................................................... 48
11 Modelos estadísticos en .......................................................... R 51

ii
i
11.1 Definiendo modelos estadísticos; formulae ............................................................. 51
11.1.1 Contrastes ..................................................................................................... 53
11.2 Modelos lineales ........................................................................................................ 54
11.3 Funciones genéricas para extraer información de modelo .................................. 54
11.4 Análisis de varianza y comparación de modelo ...................................................... 55
11.4.1 ANOVA Somete ................................................................................................ 55
11.5 Actualizando cupo modelos ................................................................................. 55
11.6 Modelos lineales generalizados ................................................................................ 56
11.6.1 Familias ................................................................................................................... 57
11.6.2 El glm() función ................................................................................................... 57
11.7 Nonlinear Menos plazas y máximos likelihood modelos ...................................... 59
11.7.1 Menos cuadra ..................................................................................................... 59
11.7.2 Máximo likelihood ............................................................................................ 61
11.8 Algunos modelos no estándares................................................................................ 61
12 Procedimientos gráficos ........................................................... 63

12.1 Alto-nivelar plotting órdenes .................................................................................... 63
12.1.1 La parcela() función ............................................................................................... 63
12.1.2 Mostrando multivariate dato ........................................................................ 64
12.1.3 Gráfico de exhibición ........................................................................................ 64
12.1.4 Argumentos a alto-nivelar plotting funciones .............................................. 65
12.2 Abajo-nivelar plotting órdenes.................................................................................. 66
12.2.1 Anotación matemática .................................................................................. 67
12.2.2 Hershey Fuentes de vector ................................................................................ 67
12.3 Interaccionando con gráficos .............................................................................. 67
12.4 Utilizando parámetros de gráfico ......................................................................... 68
12.4.1 Cambios permanentes: El par() función ....................................................... 68
12.4.2 Cambios provisionales: los argumentos a gráfico funciona ....................... 69
12.5 Lista de parámetros del gráfico ........................................................................... 69
12.5.1 Elementos gráficos ....................................................................................... 70
12.5.2 Hachas y tick marcas ................................................................................... 71
12.5.3 Márgenes de figura ............................................................................................ 71
12.5.4 Entorno de figura múltiple ................................................................................ 73
12.6 Conductores de dispositivo ....................................................................................... 74
12.6.1 Esquemas de posdata para typeset documentos........................................... 74
12.6.2 Dispositivos de gráfico múltiple ....................................................................... 75
12.7 Gráfico dinámico ....................................................................................................... 76
13 Paquetes ............................................................................................77
13.1 Paquetes estándares ...................................................................................................... 77
13.2 Contribuyó paquetes y CRAN ....................................................................................... 77
13.3 Namespaces ............................................................................................................... 78
14 OS Instalaciones ........................................................................ 79
14.1 Archivos y directorios ............................................................................................. 79
14.2 Filepaths ............................................................................................................... 79
14.3 El sistema manda ...................................................................................................... 80
14.4 Compresión y Archivos ........................................................................................... 80
Apéndice Una Una sesión de muestra ............................................ 82

Apéndice B Invocando R .............................................................. 85
i
v
B.1 Invocando R de la línea de orden .............................................................................. 85
B.2 Invocando R debajo Windows ................................................................................... 89
B.3 Invocando R bajo macOS .......................................................................................... 90
B.4 Scripting Con .................................................................................................. R 90
Apéndice C La orden-editor de línea ........................................ 92

C.1 Preliminaries ............................................................................................................... 92
C.2 Editando acciones ................................................................................................. 92
C.3 Orden-resumen de editor de la línea .......................................................................... 92
Apéndice D Función y índice variable ...................................... 94
Apéndice E índice de Concepto................................................... 97
Apéndice F Referencias ................................................................ 99

1
Prefacio
Este introduction a R es derived de un original puesto de las notas que describen el
S y S-Plus environments escrito en 1990–2 by Bill Venables y D unvid M. Smith cuando
en el University de Adelaide. We hUnve hizo un number de pequeño changes a r eflect
diferencias between el R y S programas, y expandió algunos de el material.
Gustaríamos extender tibios gracias a Bill Venables (y David Smith) para conceder
permiso para distribuir esta versión modificada de las notas de este modo, y para ser un
seguidor de R de manera atrás.
Los comentarios y las correcciones son siempre bienvenidos. Complacer correspondencia de email de la
dirección a
R-core@r-project.org.
Sugerencias al lector
La mayoría de R los novatos empezarán con la sesión introductoria en Apéndice Un.
Esto tendría que dar alguna familiaridad con el estilo de R sesiones y más importantly
alguna retroalimentación de instante en qué de hecho pasa.
Muchos usuarios vendrán a R principalmente para sus instalaciones gráficas. Ve Capítulo
12 [Gráfico], página 63, los cuales pueden ser leídos en casi cualquier tiempo y necesita no
esperar hasta que todo las secciones de preceder han sido digeridas.
2
1 Yontroduction y preliminaries.
1.1 TÉl R entorno

R Es un integrado suite de instalaciones de software para manipulación de datos, cálculo
y exhibición gráfica. Entre otras cosas tiene
• Un dato eficaz que maneja y facilidad de almacenamiento,
• Un suite de operadores para cálculos en variedades, en particular matrices,
• Un grande, colección coherente , integrada de herramientas intermedias para análisis de datos,
• Instalaciones gráficas para análisis de datos y exhibición tampoco directamente en el
ordenador o en duro- copia, y
• Un bien desarrollado, lenguaje de programación sencillo y eficaz (llamado ‘S') cuál
incluye conditionals, bucles, el usuario definió entrada y funciones recursivas e
instalaciones de producción. (De hecho la mayoría del sistema suministró las
funciones se son escritos en el S lengua.)
El entorno “de plazo” está pretendido para caracterizar él como plenamente sistema
planeado y coherente, más que una acreción incremental de muy concreto e inflexible
herramientas, cuando es frecuentemente el caso con otro software de análisis del dato.
R Es mucho un vehículo para nuevamente desarrollando métodos de análisis de dato
interactivo. Ha desarrollado rápidamente, y ha sido extendido por una colección grande
de paquetes . Aun así, la mayoría programa escrito en R es esencialmente efímero, escrito
para una pieza sola de análisis de datos.
1.2 Related Software y documentación.

R Puede be considerado como un implementation de el S lengua which wcuando dev
eloped en Bell Lab ora- tories by Rick Serc ker, John Chambers y Allan Wilks, y también
forma la base del S-MÁS sistemas.
La evolución del S la lengua está caracterizada por cuatro libros por John Cuartos y coautor.
Para R, la referencia básica es El Nuevo S Lengua: Un Entorno de Programación para
Análisis de Datos y Gráfico por Richard Un. Becker, John M. Cuartos y Allan R. Wilks. Las
características nuevas de la 1991 liberación de S está cubierto en Modelos Estadísticos en
S editados por John
M. Cuartos y Trevor J. Hastie. Los métodos formales y las clases del paquete de métodos
están basadas en aquellos descritos en Programar con Datos por John M. Cuartos. Ve
Apéndice F [Referencias], página 99, para referencias precisas.
hay n ow un number de b ooks which describe how para utilizar R para análisis de datos y
statis tics, y d ocumentation para S /S-EL PLUS puede typically be utilizó con R, keeping
las diferencias between el S implementations en mente. Ve Sección “Lo que
documentation existe para R?” En El R sistema estadístico FUnQ.
1.3 R Y estadística.
Nuestra introducción al R el entorno no mencionó estadística, aún así mucho uso de personas R
como sistema de estadísticas. Preferimos pensar de él de un entorno dentro de qué muchos
clásico y las técnicas estadísticas modernas han sido implementadas. Unos cuantos de estos está
construido a la base R entorno, pero muchos están suministrados como paquetes. hay
aproximadamente 25 paquetes suministraron con R (llamados “paquetes” estándares “y”
recomendables) y muchos más son disponibles a través del CRAN familia de sitios de Internet (vía
https://cran.r-project.org) y en otro lugar. Más los detalles en paquetes están dados
más tarde (ve Capítulo 13 [Paquetes], página 77).
La mayoría de estadística clásica y mucho de la metodología más tardía es disponible para
uso con R, pero los usuarios pueden necesitar ser preparados para hacer un poco trabajo para
encontrarlo.
Capítulo 1: Introducción y 3
preliminaries
Hay una diferencia importante en filosofía entre S (y por ello R) y los otros sistemas
estadísticos principales. En S un análisis estadístico es normalmente hecho como series
de pasos, con los resultados intermedios que son almacenados en objetos. Así mientras
que SAS y SPSS dará copious producción de una regresión o discriminant análisis, R
dará producción mínima y almacenar los resultados en un objeto de acceso para
interrogatorio subsiguiente por más lejano R funciones.
1.4 R Y el sistema de ventana

La manera más conveniente para utilizar R es en un gráfico workstation corriendo un
windowing sistema. Esta guía está apuntada en usuarios quiénes tienen esta facilidad. En
particular ocasionalmente referiremos a el uso de R en un X sistema de ventana a pesar
de que el vasto bulk de qué está dicho aplica generalmente a cualquier implementación
del R entorno.
La mayoría de usuarios lo encontrarán necesarios de interaccionar directamente con el
sistema operativo en su ordenador de vez en cuando. En esta guía, principalmente
hablamos interacción con el sistema operativo encima máquinas de UNIX. Si estás
corriendo R debajo Windows o macOS necesitarás hacer algunos ajustamientos
pequeños.
Instalando un workstation para tomar ventaja llena del customizable características de R
es un recto- adelante si un poco procedimiento tedioso, y no será considerado más allá aquí.
Usuarios en diffi- culty tendría que buscar ayuda experta local.
1.5 Utilizando R interactivamente

Cuándo utilizas el R programa emite un puntual cuándo espera órdenes de entrada. El
default puntual es ‘>', which encima UNIX might be igual como la concha puntual, y tan
él may apporeja que nada está pasando. Aun así, cuando veremos, es fácil de cambiar a
un diferente R incitar si y ou wish. We Supondrá que la concha de UNIX incita es ‘$'.
En utilizar R debajo UNIX el procedimiento sugerido para la primera ocasión es como sigue:
1. Crear un separado sub-directorio, dice trabajo, para aguantar archivos de dato
encima que te utilizará R para este problema. Esto será el directorio laborable
siempre que utilizas R para este problema particular.
$ mkdir Trabajo
$ cd Trabajo
2. Inicio el R programa con la orden.
$ R
3. Al llegar a este punto R las órdenes pueden ser emitidas (ve más tardío).
4. Para dejar el R programa la orden es
> q()
Al llegar a este punto serás preguntado si quieres salvar el dato de vuestro R sesión.
Encima algunos sistemas esto traerá arriba de una caja de diálogo, y encima otros
recibirás un texto incita al cual te puede responder sí, ningún o cancelar (una
abreviatura de letra sola hará) para salvar el dato antes de quitting, deja sin salvar, o
regreso al R sesión. Dato qué está salvado será disponible en futuro R sesiones.
Más lejano R las sesiones son sencillas.
1. La marca trabaja el directorio laborable y empezar el programa tan antes:
$ cd Trabajo
$ R
2. Uso el R programa, rescindiendo con el q() manda al final de la sesión.
Para utilizar R debajo Windows el procedimiento para seguir es básicamente igual. Crear
una carpeta como el directorio laborable, y puesto que en el Inicio En campo en
vuestro R atajo. Entonces lanzador R por doble clicking en el icono.
preliminaries
1.6 Unn sesión introductoria

Lectores deseando conseguir un sentir para R en un ordenador antes de proceder es
fuertemente aconsejado para trabajar a través de la sesión introductoria dada en Apéndice
Un [Una sesión de muestra], página 82.
1.7 Consiguiendo ayuda con funciones y características.

R Tiene un inbuilt facilidad de ayuda similar a la facilidad de hombre de UNIX. Para
conseguir más información en cualquier función nombrada concreta, por ejemplo
solucionar, la orden es
> Ayuda(soluciona)
Una alternativa es
> ?Soluciona
Para una característica especificada por caracteres especiales, el argumento tiene que ser
encerrado en doble o solo cita, haciéndolo una “cuerda de carácter”: Esto es también
necesario para unas cuantas palabras con el significado sintáctico que incluye si, para y
función .
> Ayuda("[[")
Cualquier forma de citar la marca puede soler huir el otro, cuando en la cuerda " es
importante". Nuestra convención es para utilizar doble citar marcas para preferencia.
Encima más R ayuda de instalaciones es disponible en formato de HTML por correr
> Ayuda.Inicio()
Cuál lanzará un navegador de Web que deja las páginas de ayuda para ser explorados con
hiperenlaces. Encima UNIX, peticiones de ayuda subsiguiente están enviadas al HTML-sistema
de ayuda basada. El ‘Motor de búsqueda y Palabras clave' enlace en la página cargada por
ayuda.Inicio() es particularmente útil cuando es contiene un concepto de nivel alto lista
cuál busca aun así funciones disponibles. Pueda ser una manera grande de conseguir vuestro
bearings deprisa y para entender el breadth de qué R tiene que oferta.
La ayuda.Orden de búsqueda (alternativamente ??) Deja buscar ayuda en varias maneras.
Por ejemplo,
> ??Soluciona
Prueba ?Ayuda.Busca detalles y más ejemplos.
Los ejemplos en un tema de ayuda normalmente
puede ser corrido por
> Ejemplo(tema)
Versiones de Windows de R tener otros sistemas de ayuda opcionales: uso
> ?Ayuda
Para detalles más lejanos.
1.8 R Órdenes, sensibilidad de caso, etc.

Técnicamente R es una lengua de expresión con una sintaxis muy sencilla. Es caso sensible
cuando es la mayoría de UNIX basó paquetes, así que Un y un es símbolos diferentes y
referiría a variables diferentes. El conjunto de símbolos cuáles pueden ser utilizados en R los
nombres depende de el sistema operativo y país dentro de qué R está siendo carrera
(técnicamente en el locale en uso). Normalmente todo alfanumérico symbols es todoo wed1
(y en algún counprueba esto incluye accented letras) plus ‘.' Y ‘ _', con la restricción que
un nombre must inicio con ‘ .' O una letra, y si empieza con ‘ .' El second el carácter
no tiene que ser un dígito. Los nombres son eficazmente unlimited en longitud.
Las órdenes elementales constan de cualesquier expresiones o asignaciones . Si una
expresión está dada como orden, está evaluado, imprimido (a no ser que específicamente
hecho invisible), y el valor está perdido. Una asignación también evalúa una expresión y
pasa el valor a un variable pero el resultado no es automáticamente imprimió.
1
Para portátil R código (incluyendo que para ser utilizado en R paquetes) sólo Un–Za–z0–9 tendría que ser utilizado.
preliminaries
Las órdenes están separadas cualesquiera por un semi-colon (‘;'), o por un newline. Las
órdenes elementales pueden be grouped juntos ina un compound expresión by tirantes (‘{' y
‘ }'). Los comentarios pueden ser puestos casi2 anywhere, empezando con un hashmark (‘#'),
todo hasta el final de la línea es un comentario .
Si una orden no es completar al final de una línea, R dará un diferente puntual, por default
+
Encima segundo y líneas subsiguientes y continuar leer la entrada hasta la orden es
syntactically completo. Esto incita puede ser cambiado por el usuario. Generalmente
omitiremos la continuación puntual e indicar continuación por sencillo indenting.
Líneas de orden introdujeron en la consola está limitada 3 a aproximadamente 4095 bytes (no
caracteres).
1.9 Recall Y corrección de órdenes anteriores

Debajo muchas versiones de UNIX y encima Windows, R proporciona un mecanismo para
recordar y re- ejecutando órdenes anteriores. Las llaves de flecha verticales en el teclado
pueden soler delantero de rollo y backward a través de una historia de orden. Una vez
una orden está localizada de este modo, el cursor puede ser movido dentro de la orden que
utiliza las llaves de flecha horizontales, y los caracteres pueden ser sacados con el DEL
llave o añadido con las otras llaves. Más los detalles están proporcionados más tarde: ve
Apéndice C [La orden-editor de línea], página 92.
El recordar y editando capacidades debajo UNIX es altamente customizable. Puedes
descubrir cómo para hacer este por leer la entrada manual para el readline biblioteca.
Alternativamente, el Emacs editor de texto proporciona soporte más general mecanismos
(vía ESS, Emacs Habla Estadística) para laborable interactivamente con R. Ve Sección “R
y Emacs” en El R sistema estadístico FAQ.
1.10 Executing Órdenes de o desviando producción a un archivo

Si órdenes4 está almacenado en un archivo externo, decir órdenes.R En el trabajo de
directorio laborable, pueden ser ejecutados en cualquier tiempo en un R sesión con la orden
> Fuente("órdenes.R")
Para Fuente de Windows es también disponible en la carta de Archivo. El fregadero de función,
> Fregadero("récord.lis")
Desviará toda producción subsiguiente de la consola a un archivo externo, registro.lis. La orden
> Fregadero()
Lo restaura a la consola una vez más.
1.11 Dato permanency y sacando objetos

Las entidades que R crea y manipula es sabido como objetos. Estos pueden ser variables ,
variedades de números, cuerdas de carácter, funciones, o estructuras más generales
construyeron de tales componentes.
Durante un R sesión, los objetos están creados y almacenados por nombre ( hablamos
este proceso en la sección próxima). El R orden
> Objetos()
(Alternativamente, ls()) puede soler mostrar los nombres de (la mayoría de) el objeta
cuáles son actualmente almacenados dentro de R. La colección de los objetos actualmente
almacenados se apellida el workspace.
2
No dentro de cuerdas, ni dentro de la lista de argumento de una definición de función
3
Algunos de las consolas no te dejarán para introducir más, y entre aquellos cuál algunos silenciosamente
discard el sobrantes y algunos lo utilizarán cuando el inicio de la línea próxima.
4
De unlimited longitud.
6
Para sacar objetos la función rm es disponible:

> rm(x, y, z, tinta, junk, temp, foo, barra)
Todo objeta creado durante un R la sesión puede ser almacenada permanentemente en
un archivo para uso en futuro R sesiones. Al final de cada R sesión estás dado la
oportunidad de salvar todo los objetos actualmente disponibles. Si indicas que quieres
esto, los objetos están escritos a un archivo llamó
.RData5 en el directorio actual, y las líneas de orden utilizaron en la sesión está salvada a un
archivo llamó .Rhistory.
Cuándo R está empezado en tiempo más tardío del mismo directorio él reloads el
workspace de este archivo. Al propio tiempo el asociado manda la historia es reloaded.
Está recomendado que tendrías que utilizar los directorios laborables separados para
análisis condujeron con R. Es bastante común para objetos con nombres x y y para ser
creados durante un análisis. Los nombres así son a menudo significativos en el contexto de
un análisis solo, pero pueda ser bastante duro de decidir qué podrían ser cuándo los
varios análisis ha sido conducido en el mismo directorio.
5
El punto “principal” en este nombre de archivo lo hace invisible en listados de archivo normal en UNIX, y
en default GUI listados de archivo en macOS y Windows..
7
2 Manipulaciones sencillas; números y vectores.
2.1 Vectors y asignación.

R Opera dato nombrado encima estructuras. El más sencillo tal estructura es el vector
numérico , el cual es una entidad sola constando de una colección ordenada de números.
Para instalar un vector nombró x, dice, constando de cinco números, concretamente 10.4,
5.6, 3.1, 6.4 y 21.7, uso el R orden
> x <- c(10.4, 5.6, 3.1, 6.4, 21.7)
Esto es una declaración de asignación utilizando la función c() cuáles en este contexto
pueden tomar un número arbitrario de argumentos de vector y cuyo valor es un vector
conseguido por concatenar su fin de argumentos para acabar.1
Un número que ocurre por él en una expresión está tomada como vector de longitud un.
Aviso que el assignment operator (‘<-'), which consta de el t wo characters ‘<' (“menos
de”) y ‘ -' (“minnos”) occurring estrictamente lado-by-lado y él ‘points' a elo bject
recibiendo el value de la expresión. En más contextos el ‘=' operator puede be utilizado
como un alternative.
La asignación también puede ser hecha utilizando la función asigna(). Una manera
equivalente de hacer la misma asignación tan encima es con:
> Asigna("x", c(10.4, 5.6, 3.1, 6.4, 21.7))
El operador habitual, <-, puede ser pensado de como sintáctico corto-cortado a esto.
Las asignaciones también pueden ser hechas en la otra dirección, utilizando el cambio
obvio en el asignar- ment operador. Así que la misma asignación podría ser hecha
utilizando
> c(10.4, 5.6, 3.1, 6.4, 21.7) -> x
Si una expresión está utilizada como orden completa, el valor está imprimido y perdió 2.
Tan ahora si éramos para utilizar la orden
> 1/x
El reciprocals de los cinco valores serían imprimidos en la terminal (y el valor de x ,
naturalmente, sin cambios).
La asignación más lejana
> y <- c(x, 0, x)
Crearía un vector y con 11 entradas que constan de dos copias de x con un cero en el sitio
medio.
2.2 Vector aritmética

Los vectores pueden ser utilizados en expresiones de aritmética, en qué caso las operaciones
están actuadas elemento por elemento. Los vectores que ocurren en la misma expresión
necesita no todo ser de la misma longitud. Si no son, el valor de la expresión es un vector
con la misma longitud como el vector más largo qué ocurre en la expresión. Los vectores más
cortos en la expresión están reciclados tan a menudo tan necesidad ser (quizás fractionally)
hasta que emparejan la longitud del vector más largo. En particular una constante es
sencillamente repitió. Tan con el por encima de asignaciones la orden.
> v <- 2*x + y + 1
Genera un vector nuevo v de longitud 11 construido por añadir junto, elemento por elemento, 2*x
Repetido 2.2 tiempo, y repitió justo una vez, y 1 repitió 11 tiempo.
1
Con otro que tipos de vector de argumento, como argumentos de modo de la lista, la acción de
c() es bastante diferente. Ve Sección 6.2.1 [Concatenando listas], página 27.
2
De hecho, es todavía disponible cuando .Último.El valor antes de cualesquier otras declaraciones está ejecutado.
Capítulo 2: manipulaciones Sencillas; números y 8
vectores
Los operadores de aritmética elementales son el habituales +, -, *, / y ^ para levantar a un

poder. Además todos de las funciones de aritmética comunes son disponibles. Registro, exp,
pecado, cos, bronceado, sqrt, y tan encima, todos tienen su significado habitual. max Y
min seleccionar los elementos más grandes y más pequeños de un vector respectivamente. La
gama es una función cuyo valor es un vector de longitud dos, concretamente c(min(x),
max(x)). Longitud(x) es el número de elementos en x, suma(x) da el total de los
elementos en x, y prod(x) su producto.
Dos funciones estadísticas son malas(x) cuál calcula la muestra mala, el cual es el mismo
tan suma(x)/longitud(x), y var(x) cuál da
Suma((x-malo(x))^2)/(longitud(x)-1)
O varianza de muestra. Si el argumento a var() es un n-por-p matriz el valor es unp -por-p
matriz de covarianza de la muestra conseguida por con respecto a las filas como
independientes p-variate vectores de muestra.
Clase(x) regresa un vector de la misma medida como x con los elementos arreglaron en
orden creciente; aun así hay otro más flexible ordenando las instalaciones disponibles (ve
orden() o clase.Lista() cuáles producen una permutación para hacer el ordenando).
Nota que max y min seleccionar los valores más grandes y más pequeños en sus
argumentos, incluso si están dados varios vectores . El máximo paralelo y funciones mínimas
pmax y pmin regresar un vector (de la longitud igual a su argumento más largo) aquello
contiene en cada elemento el más grande (más pequeño) elemento en aquella posición en
cualquier de los vectores de entrada.
Para más propósitos el usuario no será preocupado si los “números” en un vector
numérico son enteros, reals o incluso complejos. Internamente los cálculos están hechos
como precisión doble números reales, o precisión doble números complejos si el dato de
entrada es complejo.
Para trabajar con números complejos, suministro una parte compleja explícita. Así
sqrt(-17)
Dará NaN y un aviso, pero
sqrt(-17+0i)
Hará las computaciones como números complejos.
2.3 Generando secuencias regulares

R Tiene un número de instalaciones para generar generalmente utilizó secuencias de números.
Por ejemplo 1:30 es el vector c(1, 2, ..., 29, 30). El operador de colon tiene
prioridad alta dentro de un ex- pression, así que, por ejemplo 2*1:15 es el vector c(2, 4,
..., 28, 30). Puesto n <- 10 y comparar las secuencias 1:n-1 y 1:(n-1) .
La construcción 30:1 puede soler generar una secuencia atrás.
La función seq() es una facilidad más general para generar secuencias. Tiene cinco
argumentos, sólo algunos de los cuales pueden ser especificados en cualquiera llama. Los
primeros dos argumentos, si dados, especificar el principio y fin de la secuencia, y si estos son
el únicos dos argumentos dados el resultado es igual como el operador de colon. Aquello
es seq(2,10) es el mismo vector cuando 2:10.
Argumentos a seq() , y a muchos otro R funciones, también puede ser dado en forma
nombrada, en qué caso el orden en qué aparecen es irrelevante. Los primeros dos argumentos
pueden ser nombrados de=valor y para= valorar; por ello seq(1,30), seq(de=1, a=30) y
seq(a=30, de=1) es todo el mismo tan 1:30. El próximo dos argumentos a seq() puede ser
nombrado por=valor y valor= de longitud, los cuales especifican una medida de paso y
una longitud para la secuencia respectivamente. Si tampoco de estos está dado, el default
por=1 está supuesto.
Por ejemplo
> seq(-5, 5, por=.2) -> s3
Genera en s3 el vector c(-5.0, -4.8, -4.6, ..., 4.6, 4.8, 5.0). De modo parecido
> s4 <- seq(longitud=51, de=-5, por=.2)
vectores
Genera el mismo vector en s4.

El quinto argumento puede ser nombrado a lo largo de=vector, el cual es
normalmente utilizado como el único argument para crear la secuencia 1, 2, ...,
longitud(vector), o la secuencia vacía si el vector es vacío (cuando pueda ser).
Una función relacionada es rep() cuáles pueden ser utilizados para replicating un objeto
en varios complicó maneras. La forma más sencilla es
> s5 <- rep(x, cronometra=5)
Cuál pondrá cinco copias de x fin-a-fin en s5. Otra versión útil es
> s6 <- rep(x, cada cual=5)
Cuál repite cada elemento de x cinco tiempo antes de emotivo encima al próximo.
2.4 Logical vectores

Así como vectores numéricos, R deja manipulación de cantidades lógicas. Los elementos de
un vector lógico pueden tener los valores CIERTOS, FALSOS, y NA (para “no disponibles”,
ve abajo). El primeros dos son a menudo abreviados como T y F , respectivamente. Nota
aun así que T y F es variables justas qué está puesto a CIERTO y FALSO por default,
pero no es reservó palabras y de ahí puede ser overwritten por el usuario. De ahí, siempre
tendrías que utilizar CIERTO y FALSO .
Los vectores lógicos están generados por condiciones. Por ejemplo
> temp <- x > 13
Conjuntos temp como vector de la misma longitud como x con los valores FALSOS correspondiendo a
elementos de x.
Dónde la condición no es conocida y CIERTO donde es.
Los operadores lógicos son <, <=, >, >=, == para igualdad exacta y != Para desigualdad.
Además si c1 y c2 es expresiones lógicas, entonces c1 & c2 es su intersección (“y”), c1 |
c2 es su unión (“o”), y !c1 es la negación de c1 .
Los vectores lógicos pueden ser utilizados en aritmética normal, en qué caso están
coaccionados a vectores numéricos, FALSOS deviniendo 0 y CIERTOS deviniendo 1.
Aun así hay situaciones donde vectores lógicos y su coaccionados numéricos counterparts no
es equivalente, por ejemplo ver el inciso próximo.
2.5 Missing Valores

En algunos casos los componentes de un vector no puede ser completamente sabido.
Cuándo un elemento o el valor no “es disponibles” o un “valor desaparecido” en el
sentido estadístico, un sitio dentro de un vector puede ser reservado para él por asignarlo el
valor especial NA. En general cualquier operación en un NA deviene un NA. La
motivación para esta regla es sencillamente que si la especificación de una operación es
incompleta, el resultado no puede ser sabido y de ahí no es disponible.
La función is.na(x) da un vector lógico de la misma medida como x con valorar
CIERTO si y sólo si el elemento correspondiente en x es NA.
> z <- c(1:3,NA); ind <- is.na(z)
Aviso que la expresión lógica x == NA es bastante diferente de is.na(x) desde NA no es
realmente un valor pero un marcador para una cantidad que no es disponible. Por ello x ==
NA es un vector de la misma longitud como x todos de de quién valores son NA como la
expresión lógica él es incompleto y de ahí indecidible.
Nota que hay una segunda clase de “desaparecido” valora cuáles están producidos por
numéricos com- putation, el tan-llamó No un Número, NaN, valores. Los ejemplos son
> 0/0
O
> Inf - Inf
vectores
Qué ambos dan NaN desde el resultado no puede ser definido sensibly.
En resumen, is.na(xx) es CIERTO ambos para NA y NaN valores. Para diferenciar estos,
Es.nan(xx) Es sólo CIERTO para NaNs.
Los valores desaparecidos son a veces imprimidos tan <NA> cuándo vectores de carácter
están imprimidos sin cita.
2.6 Character Vectores

Cantidades de carácter y vectores de carácter están utilizados frecuentemente en R, por ejemplo
tan etiquetas de parcela. Dónde necesitado están denotados por una secuencia de caracteres
delimitó por el doble cita carácter, p. ej., "x-valores", "resultados de iteración
Nueva".
Cuerdas de carácter están introducidas utilizando cualquier emparejando dobles (") o
solos (') cita, pero está imprimido utilizando doble cita (o a veces sin cita). Utilizan
escapada de C estilos secuencias, utilizando \ como el carácter de escapada, así que \\
está introducido e imprimido tan \\, y dentro de doble cita " está introducido cuando \".
Otras secuencias de escapada útiles son \n, newline, \t, tabulador y \b , backspace—ve
?Cita para una lista llena.
Vectores de carácter pueden ser concatenados a un vector por el c() función; los
ejemplos de su uso emergerán frecuentemente.
La pasta() la función toma un número arbitrario de argumentos y les concatena uno por
uno a cuerdas de carácter. Cualesquier números dados entre los argumentos están
coaccionados a cuerdas de carácter en la manera evidente, aquello es, en la misma manera
serían si estuvieron imprimidos. Los argumentos son por default separados en el resultado
por un carácter de espacio solo, pero esto puede ser cambiado por el argumento nombrado,
sep=cuerda, el cual lo cambia a cuerda , posiblemente vacío.
Por ejemplo
> Laboratorios <- pasta(c("X","Y"), 1:10, sep="")
Laboratorios de marcas al vector de carácter
c("X1", "Y2", "X3", "Y4", "X5", "Y6", "X7", "Y8", "X9", "Y10")
Nota particularmente que reciclando de las listas cortas tiene lugar aquí demasiado; por
ello c("X", "Y") está repetido 5 tiempo para emparejar la secuencia 1:10.3
2.7 Yondex vectores; seleccionando y modificando subconjuntos de un

conjunto de dato
Subconjuntos de los elementos de un vector pueden ser seleccionados por anexar al nombre
del vector un vector de índice en paréntesis cuadrados. Más generalmente cualquier
expresión que evalúa a un vector puede tener subconjuntos de sus elementos de modo
parecido seleccionados por anexar un vector de índice en paréntesis cuadrados
inmediatamente después de la expresión.
Tales vectores de índice pueden ser cualesquiera de cuatro tipos distintos.
1. Un vector lógico. En este caso el vector de índice está reciclado a la misma longitud
como el vector de qué elementos es para ser seleccionado. Los valores que corresponden
a CIERTOS en el vector de índice está seleccionado y aquellos correspondiente a
FALSO está omitido. Por ejemplo.
> y <- x[!is.na(x)]
Crea (o recrea) un objeto y cuál contendrá los valores no desaparecidos de x , en el
mismo orden. Nota que si x tiene perder valores, y será más corto que x. También
> (x+1)[(!is.na(x)) & x>0] -> z
Crea un objeto z y sitios en él los valores del vector x+1 para qué el valor
correspondiente en x era ambos no-desaparecido y positivo.
3
Pasta(..., derrumbamiento=ss) une los argumentos a una cuerda de carácter sola que pone ss en entre, p. ej., ss
<- "|". hay más herramientas para manipulación de carácter, ver la ayuda para sub y subcadena.
vectores
2. Un vector de cantidades integrales positivas. En este caso los valores en la mentira de

mosto de {vector de índice en} el conjunto 1, 2, . . . , longitud(x) . Los elementos
correspondientes del vector están seleccionados y concatenados, en aquel orden, en el
resultado. El vector de índice puede ser de cualquier longitud y el resultado es de la misma
longitud como el vector de índice. Por ejemplo x[6] es el sexto componente de x y
> x[1:10]
Selecciona los primeros 10 elementos de x (suponiendo longitud(x) no es menos de 10). También
> c("x","y")[rep(c(1,2,2,1), cronometra=4)]
(Una cosa ciertamente improbable para hacer) produce un vector de carácter de longitud 16 constando
de
"x", "y", "y", "x" repitió cuatro tiempo.
3. Un vector de cantidades integrales negativas. Tal un vector de índice especifica los valores para
ser
Excluido más que incluido. Así
> y <- x[-(1:5)]
Da y todo pero los primeros cinco elementos de x .
4. Un vector de cuerdas de carácter. Esta posibilidad sólo aplica donde un objeto tiene
un atributo de nombres para identificar sus componentes. En este caso un sub-el
vector del vector de nombres puede ser utilizado en la misma manera como las
etiquetas integrales positivas en elemento 2 más allá encima.
> Fruta <- c(5, 10, 1, 20)
> Nombres(fruta) <- c("naranja", "plátano", "manzana", "melocotón")
> Comida <- fruta[c("manzana","naranja")]
La ventaja es que los nombres alfanuméricos son a menudo más fáciles de recordar
que índices numéricos. Esta opción es particularmente útil en conexión con marcos de
datos, cuando veremos más tarde.
Un indexed la expresión también puede aparecer en el fin de recibir de una asignación, en
qué caso la operación de asignación está actuada sólo en aquellos elementos del vector.
La expresión tiene que ser del vector de forma[vector_de índice] cuando habiendo
una expresión arbitraria en sitio del nombre de vector no hace mucho sentido aquí.
Por ejemplo
> x[is.na(x)] <- 0
Reemplaza cualesquier valores desaparecidos en x por ceros y
> y[y < 0] <- -y[y < 0]
Tiene el mismo efecto cuando
> y <- abs(y)
2.8 Other Tipos de objetos.

Los vectores son el tipo más importante de objeto en R, pero hay muchos otros cuál
conoceremos más formalmente en secciones más tardías.
• Matrices o más generalmente las variedades son multi-generalizaciones
dimensionales de vectores. De hecho, son vectores que puede ser indexed por dos o
más índices y será imprimido en maneras especiales. Ve Capítulo 5 [Variedades y
matrices], página 18.
• Los factores proporcionan maneras compactas para manejar dato categórico. Ve
Capítulo 4 [Factores], página 16. Las listas son una forma general de vector en qué
• los varios elementos necesitan no ser del mismo tipo, y es a menudo ellos vectores o
listas. Las listas proporcionan una manera conveniente de regresar el
Resultados de una computación estadística. Ve Sección 6.1 [Listas], página 26.
• Marcos de dato son matriciales-como estructuras, en qué las columnas pueden ser de tipos
diferentes. Piensa de los datos enmarca tan ‘matrices de dato' con uno rema por unidad
observacional pero con (posiblemente).
vectores
Ambas variables numéricas y categóricas. Muchos experimentos son más descritos

por marcos de datos: los tratamientos son categóricos pero la respuesta es numérica.
Ve Sección 6.3 [marcos de Dato], página 27.
• Las funciones se son objeta en R cuáles pueden ser almacenados en el proyecto
workspace. Esto proporciona una manera sencilla y conveniente para extender R. Ve
Capítulo 10 [Escribiendo vuestras funciones propias], página 42.
13
3 Objects, sus modos y atributos.
3.1 Yontrinsic atributos: modo y longitud.

Las entidades R opera encima es técnicamente sabido como objetos. Los ejemplos son vectores
de numéricos (reales) o valores complejos, vectores de vectores y valores lógicos de cuerdas
de carácter. Estos son sabidos como “las estructuras” atómicas desde sus componentes son todos
del mismo tipo, o modo , concretamente numérico1, complejo, lógico, carácter y crudo .
Los vectores tienen que tener su valora todo del mismo modo. Por ello cualquier vector dado
tiene que ser un- ambiguamente cualquier lógico, numérico, complejo, carácter o crudo . (La
excepción aparente única a esta regla es el valor “especial” listó tan NA para las cantidades no
disponibles, pero de hecho hay varios tipos de NA ). Nota que un vector puede ser vacío y
todavía tener un modo. Por ejemplo el vector de cuerda de carácter vacío está listado tan
carácter(0) y el vector numérico vacío como numérico(0).
R También opera en los objetos llamaron listas, los cuales son de lista de modo. Estos
son ordenó secuencias de objetos qué individualmente puede ser de cualquier modo. Las
listas son sabidas como “recursivos” más que las estructuras atómicas desde sus
componentes pueden ellos ser listas en su derecho propio.
Las otras estructuras recursivas son aquellas de función de modo y expresión . Las
funciones son los objetos que parte de forma del R sistema junto con el usuario similar
escrito funciona, el cual hablamos en algún detalle más tarde. Las expresiones como objetos
forman una parte adelantada de R cuál no será hablado en esta guía, exceptúa
indirectamente cuándo hablamos formulae utilizados con modeling en R.
Por el modo de un objeto significamos el tipo básico de sus electores fundamentales. Esto es
un caso especial de una “propiedad” de un objeto. Otra propiedad de cada objeto es su
longitud. El modo de funciones(objeto) y longitud( objeto) puede soler descubrir
el modo y longitud de cualquier estructura definida2.
Las propiedades más lejanas de un objeto son normalmente proporcionados por
atributos(objeto), ve Sección 3.3 [Consiguiendo y poniendo atributos], página 14.
Debido a este, el modo y la longitud son también atributos “intrínsecos llamados” de un
objeto.
Por ejemplo, si z es un vector complejo de longitud 100, entonces en un modo de
expresión(z) es el complejo de cuerda "del carácter" y longitud(z) es 100.
R Provee para cambios de modo casi anywhere pueda ser considerado sensato de
hacer tan, (y unos cuantos donde lo no podría ser). Por ejemplo con
> z <- 0:9
Podríamos poner
> Dígitos <- cuando.Carácter(z)
Después de qué dígitos es el vector de carácter c("0", "1", "2", ..., "9"). Un más
lejano coercion, o cambio de modo, reconstruye el vector numérico otra vez:
> d <- Cuando.Entero(dígitos)
Ahora d y z es igual. 3 hay una colección grande de funciones de la forma cuando.Algo()
para cualquier coercion de un modo a otro, o para invertir un objeto con algunos otro atributo
pueda no ya poseer. El lector tendría que consultar los archivos de ayuda diferentes para devenir
familiar con ellos..
1
El modo numérico es de hecho una amalgama de dos modos distintos, concretamente entero y precisión
doble, cuando explicado en el manual.
2
Nota aun así que longitud(objeto) no siempre contener información útil intrínseca, p. ej., cuándo el
objeto es una función .
3
En general, coercion de numérico a carácter y atrás otra vez no será exactamente reversible, debido a
roundoff errores en la representación de carácter.
Capítulo 3: Objetos, sus modos y atributos. 14
3.2 Cambiando la longitud de un objeto

Un “objeto” vacío todavía puede tener un modo. Por ejemplo
> e <- Numérico()
Marcas e una estructura de vector vacía del modo numérico. De modo parecido carácter()
es un vector de carácter vacío, y tan encima. Una vez un objeto de cualquier medida ha sido
componentes creados , nuevos puede ser añadido a él sencillamente por darlo un valor de
índice fuera de su gama anterior. Así
> e[3] <- 17
Ahora hace e un vector de longitud 3, (los primeros dos componentes de los cuales son
al llegar a este punto ambos NA). Esto aplica a cualquier estructura en absoluto,
proporcionado el modo del componente adicional(s) está de acuerdo con el modo del
objeto en primer lugar..
Este ajustamiento automático de las longitudes de un objeto está utilizada a menudo, por ejemplo en el
escáner()
Función para entrada. (Ve Sección 7.2 [El escáner() función], página 31.)
En cambio para truncar la medida de un objeto requiere sólo una asignación para hacer tan. De ahí
si
La alfa es un objeto de longitud 10, entonces
> Alfa <- alfa[2 * 1:5]
Lo hace un objeto de longitud 5 constando de justo los componentes anteriores con
incluso índice. (Los índices viejos no son retenidos, naturalmente.) Entonces podemos
retener justo los primeros tres valores por
> Longitud(alfa) <- 3
Y los vectores pueden ser extendidos (por valores desaparecidos) en la misma manera.
3.3 Consiguiendo y poniendo atributos

Los atributos de función(objeto) regresa una lista de todo los atributos no intrínsecos
actualmente definidos para aquel objeto. La función attr(objeto, nombre) puede soler
seleccionar un atributo concreto. Estas funciones son raramente utilizadas, exceptúa en
circunstancias bastante especiales cuándo algunos el atributo nuevo está siendo creado para
algún propósito particular, por ejemplo para asociar una fecha de creación o un operador
con un R objeto. El concepto, aun así, es muy importante.
Algún cuidado tendría que ser ejercitado cuándo asignando o eliminando atributos desde
entonces son una parte integral del sistema de objeto utilizado en R.
Cuándo está utilizado en el lado de mano izquierdo de una asignación pueda ser utilizado
tampoco para asociar un atributo nuevo con objeto o para cambiar un existiendo un. Por
ejemplo.
> attr(z, "dim") <- c(10,10)
Deja R para tratar z como si sea un 10 -por-10 matriz.
3.4 TÉl clase de un objeto

Todos los objetos en R tener una clase, informado por la clase de función. Para vectores
sencillos este es justo el modo, por ejemplo "numérico", "lógico", "carácter" o lista "", pero
"matriz", "variedad", "factor" y dato.El "marco" es otros valores posibles .
Un atributo especial sabido como la clase del objeto suele dejar para un objeto-estilo
orientado4 de programar en R. Por ejemplo si un objeto tiene dato "de clase.Marco", sea
imprimido en una manera segura, la parcela() la función lo mostrará graphically en una manera
segura, y otro tan-funciones genéricas llamadas como resumen() reaccionará a él cuando un
argumento en una manera sensible a su clase.
Para sacar temporalmente los efectos de clase, uso la función unclass(). Por ejemplo si el
invierno tiene el dato "de clase.Marco" entonces
> Invierno
4 Un estilo diferente que utiliza ‘formal' o ‘S4' las clases está proporcionada en métodos de paquete.
Capítulo 3: Objetos, sus modos y atributos. 15
Imprimirá él en forma de marco de los datos, el cual es bastante como una matriz, mientras que
> unclass(Invierno)
Lo imprimirá cuando una lista normal. Sólo en situaciones bastante especiales necesitas
utilizar esta facilidad, pero uno es cuándo tú está aprendiendo para venir a plazos con la
idea de clase y funciones genéricas. Clases y funciones genéricas serán habladas más allá
en Sección 10.9 [orientación de Objeto],
Página 48, pero sólo brevemente.
16
4 Ordenado y unordered factores

Un factor es un objeto de vector utilizó para especificar una clasificación discreta (agrupación)
de los componentes de otros vectores de la misma longitud. R Proporciona ambos ordenado y
unordered factores. Mientras la “aplicación” real de factores es con modelo formulae (ve
Sección 11.1.1 [Contrastes], página 53), nosotros aquí mirada en un ejemplo concreto.
4.1 Un ejemplo concreto

Supone, por ejemplo, tenemos una muestra de 30 contables de impuesto de todos los
estados y territorios de Australia1 y su estado individual de origen está especificado por
un vector de carácter de estatal mnemonics cuando
> Estatal <- 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", "acto", "nsw", "vic", "vic", "acto")
Aviso que en el caso de unc haracter vector, “so ted” significa ordenado en alphab
etical orden. Un factor es de modo parecido creó utilizar el factor() función:
> statef <- Factor(estatal)
La impresión() factores de mangos de la función ligeramente de manera diferente de otros objetos:
> statef
[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 acto nsw vic vic
Niveles de acto: acto nsw nt qld sa tas vic wa
Para descubrir los niveles de un factor los niveles de función() puede ser utilizado.
> Niveles(statef)
[1] "acto" "nsw" "nt" "qld" "sa" "tas" "vic" "wa"
4.2 La función tapply() y ragged variedades

Para continuar el ejemplo anterior, supone tenemos los ingresos de los mismos
contables de impuesto en otro vector (en suitably unidades grandes de dinero).
> Ingresos <- 49, 40, 61, 64, 60, 59, 54, 62, 69, 70, 42, 56,
c(60,
61, 61, 61, 58, 51, 48, 65, 49, 49, 41, 48, 52, 46,
59, 46, 58, 43)
Para calcular la muestra ingresos malos para cada estado ahora podemos utilizar la función especial
tapply():
> incmeans <- tapply(Ingresos, statef, malos)
Dando un vector de medio con los componentes etiquetó por los niveles
Acto nsw nt qld sa tas vic wa
44.500 57.333 55.500 53.600 55.000 60.500 56.000 52.250
La función tapply() suele aplicar una función, aquí significar(), a cada grupo de
componentes del primer argumento, aquí ingresos, definidos por los niveles del segundo
componente, aquí statef2,
1
Los lectores tendrían que notar que hay ocho estados y territorios en Australia, concretamente el
Territorio Capital australiano, Gales Del sur Nuevo, el Territorio Del norte, Queensland, Australia Del
sur, Tasmania, Victoria y Australia Occidental.
2
Nota que tapply() también works en este caso cuándo su segundo argument no es un factor, p. ej.,
‘tapply(ingresos, estado)', y t hes es cierto para bastante unas cuantas otras funciones, desde
arguments es c oerced a f unctors cuándo necesario (utilizando cuando.Factor()).
Capítulo 4: Ordenado y unordered 17
factores
Como si eran estructuras de vector separado . El resultado es una estructura de la misma

longitud como el atributo de niveles de el factor que contiene los resultados. El lector
tendría que consultar el documento de ayuda para más detalles.
Supone más allá necesitamos calcular los errores estándares de los ingresos estatales
significa. Para hacer este necesitamos escribir un R función para calcular el error estándar
para cualquier vector dado. Desde entonces hay un builtin función var() para calcular la
varianza de muestra, tal función es un muy sencillo un liner, especificado por la asignación:
> stdError <- Función(x) sqrt(var(x)/longitud(x))
(Escribiendo las funciones serán consideradas más tarde en Capítulo 10 [Escribiendo vuestras
funciones propias], página 42. Nota que R es un builtin función sd() es algo diferente.)
Después de esta asignación, los errores estándares están calculados por
> incster <- tapply(Ingresos, statef, stdError)
Y los valores calcularon es entonces
> incster
Acto nsw nt qld sa tas vic wa
1.5 4.3102 4.5 4.1061 2.7386 0.5 5.244 2.6575
Cuando un ejercicio te puedes preocupar para encontrar el habitual 95% límites de confianza
para los ingresos malos estatales. Para hacer este te podría utilizar tapply() una vez más
con la longitud() función para encontrar las medidas de muestra, y el qt() función para
encontrar los puntos de porcentaje del apropiados t- distribuciones. (También podrías investigar R
instalaciones para t -pruebas.)
La función tapply() también puede soler manejar indexación más complicada de un
vector por categorías múltiples. Por ejemplo, podríamos desear partir los contables de
impuesto por ambos estatales y sexo. Aun así en este caso sencillo (justo un factor) qué pasa
puede ser pensado de como sigue. Los valores en el vector están recogidos a los grupos que
corresponden a las entradas distintas en el factor. La función es entonces aplicada a cada
cual de estos grupos individualmente. El valor es un vector de resultados de función,
etiquetados por el atributo de niveles del factor.
La combinación de un vector y un factor de etiquetar es un ejemplo de qué es a veces llamó
un ragged variedad, desde las medidas de subclase son posiblemente irregulares. Cuándo las
medidas de subclase son todo la misma la indexación puede ser hecha implícitamente y mucho
más efficiently, cuando vemos en la sección próxima.
4.3 O rdered Factores

Los niveles de factores están almacenados por orden alfabético, o en el orden estuvieron especificados
a
Factor si estuvieron especificados explícitamente.
A veces los niveles tendrán un naturales ordenando que queremos récord y querer
nuestro análisis estadístico para hacer uso de. El ordenado() la función crea tal ordenó
factores pero es otherwise idéntico a factor . Para más propósitos la diferencia única entre
ordenado y unordered los factores es que el anteriores está imprimido mostrando el ordenando
de los niveles, pero los contrastes generaron para ellos en caber los modelos lineales son
diferentes.
18
5 Arrays Y matrices.
5.1 Unrrays
Una variedad puede ser considerada como multiplicar subscripted colección de entradas
de datos, por ejemplo numéricos. R Deja instalaciones sencillas para crear y manejando
variedades, y en particular el caso especial de matrices.
Un vector de dimensión es un vector de enteros no negativos. Si su longitud es k entonces
la variedad es k-dimensional, p. ej. una matriz es una 2 -variedad dimensional. Las
dimensiones son indexed de uno hasta los valores dados en el vector de dimensión.
Un vector puede ser utilizado por R como una variedad sólo si tiene un vector de dimensión como su
dim atributo.
Supone, por ejemplo, z es un vector de 1500 elementos. La asignación
> dim(z) <- c(3,5,100)
Lo da el dim atributo que lo deja para ser tratado como 3 por 5 por 100 variedad.
Otras funciones como matriciales() y variedad() es disponible para más sencillo y
más natural mirando asignaciones, cuando veremos en Sección 5.4 [La variedad() función],
página 20.
Los valores en el vector de dato dan los valores en la variedad en el mismo orden
cuando ocurrirían en FORTRAN, aquello es columna “ orden importante,” con el primer
subíndice que mueve más rápido y el último subíndice más lento.
× ×
Por ejemplo si el vector de dimensión para una variedad, decir un, es c(3,4,2) entonces hay 3 4
2 = 24 entradas en un y el vector de dato les aguanta en el orden un[1,1,1],
un[2,1,1], ..., un[2,4,2], un[3,4,2].
Las variedades pueden ser unidimensionales: tales variedades son normalmente tratadas
en la misma manera como vectores (incluyendo cuándo impresión), pero las excepciones
pueden causar confusión.
5.2 Unrray indexación. Incisos de una variedad

Los elementos individuales de una variedad pueden ser referenced por dar el nombre de
la variedad seguida por los subíndices en paréntesis cuadrados, separados por comas.
Más generalmente, los incisos de una variedad pueden ser especificados por dar una secuencia
de vectores de índice en sitio de subíndices; aun así si cualquier posición de índice está dada
un vector de índice vacío , entonces la gama llena de aquel subíndice está tomada.
Continuando el ejemplo anterior, un[2,,] es×una 4 2 variedad con vector de dimensión
c(4,2) y vector de dato que contiene los valores
c(Un[2,1,1], un[2,2,1], un[2,3,1], un[2,4,1],
Un[2,1,2], un[2,2,2], un[2,3,2], un[2,4,2])
En aquel orden. Un[,,] posiciones para la variedad entera, el cual es el mismo tan
omitiendo los subíndices enteramente y utilizando un solos.
Para cualquier variedad, dice Z, el vector de dimensión puede ser referenced explícitamente
cuando dim(Z) (en cualquier lado de una asignación).
También, si un nombre de variedad está dado con justo un subíndice o vector de índice,
entonces los valores correspondientes del vector de dato sólo está utilizado; en este caso el vector
de dimensión está ignorado. Esto no es el caso, aun así, si el índice solo no es un vector
pero él una variedad, cuando luego hablamos.
Capítulo 5: Variedades y 19
matrices
5.3 Matrices de índice

Así como un vector de índice en cualquier posición de subíndice, una matriz puede ser
utilizada con una matriz de índice sola en ordenar tampoco para asignar un vector de
cantidades a una colección irregular de elementos en la variedad, o para extraer una
colección irregular como vector.
Un ejemplo matricial hace el proceso claro. En el caso de un doblemente indexed
variedad, una matriz de índice puede ser dada constando de dos columnas y cuando muchos
rema tan deseados. Las entradas en la matriz de índice son la fila y índices de columna para
el doblemente indexed variedad. Supone por ejemplo tenemos un 4 por 5 variedad X y
deseamos hacer el siguientes:
• Elementos de extracto X[1,3], X[2,2] y X[3,1] como estructura de vector, y
• Reemplazar estas entradas en la variedad X por zeroes.
En este caso necesitamos un 3 por 2 variedad de subíndice, cuando en el ejemplo siguiente.
> x <- Variedad(1:20, dim=c(4,5)) # Genera un 4 por 5 variedad.
> 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 <- dim=c(3,2))
Variedad(c(1:3,3:1),
> i # i Es un 3 por 2 variedad de
índice.
[,1] [,2]
[1,] 1 3
[2,] 2 2
[3,] 3 1
> x[i] # Extracto aquellos elementos
[1] 9 6 3
> x[i] <- 0 # Reemplazar aquellos 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
>
Los índices negativos no son dejados en matrices de índice. NA Y cero valores están
dejados: filas en la matriz de índice que contiene un cero está ignorado, y rema contener un
NA producto un NA en el resultado.
Como menos ejemplo trivial, supone deseamos generar un (unreduced) matriz de diseño
para un diseño de bloque definido por bloques de factores (b niveles) y variedades (v
niveles). Más allá suponer hay n parcelas en el experimento. Podríamos proceder como sigue:.
> Xb <- Matricial(0, n, b)
> Xv <- Matricial(0, n, v)
> ib <- cbind(1:n, bloques)
> iv <- cbind(1:n, variedades)
> Xb[ib] <- 1
> Xv[iv] <- 1
> X <- cbind(Xb, Xv)
Para construir la matriz de incidencia, N dice, podríamos utilizar
> N <- crossprod(Xb, Xv)
matrices
Aun así una manera directa más sencilla de producir esta matriz es para utilizar mesa():
> N <- Mesa(bloques, variedades)
Matrices de índice tienen que ser numéricas: cualquiera otra forma de matricial (p. ej.
un lógico o matriz de carácter) suministró como matricial está tratado como un vector de
indexación.
5.4 La variedad() función

Así como dando un vector estructura un dim atributo, las variedades pueden ser
construidas de vectores por la función de variedad, el cual tiene la forma.
> Z <- Variedad(vector_de dato, dim_vector)
Por ejemplo, si el vector h contiene 24 o menos, números entonces la orden
> Z <- Variedad(h, dim=c(3,4,2))
Utilizaría h para instalar 3 por 4 por 2 variedad en Z. Si la medida de h es exactamente 24
el resultado es igual cuando
> Z <- h ; dim(Z) <- c(3,4,2)
Aun así si h es más corto que 24, sus valores están reciclados desde el principio otra vez para
hacerlo a medida 24 (ve Sección 5.4.1 [La regla de reciclaje], página 20) pero dim(h) <-
c(3,4,2) señalaría un error sobre mismatching longitud. Cuando un extremo pero ejemplo
común
> Z <- Variedad(0, c(3,4,2))
Marcas Z una variedad de todos los ceros.
Al llegar a este punto dim(Z) posiciones para el vector de dimensión c(3,4,2), y Z[1:24]
posiciones para el vector de dato cuando sea enh , y Z[] con un subíndice vacío o Z sin
posiciones de subíndice para la variedad entera como una variedad.
Las variedades pueden ser utilizadas en expresiones de aritmética y el resultado es una
variedad formada por elemento- por-operaciones de elemento en el vector de dato. El dim
atributos de los operandos generalmente necesitan ser igual, y esto deviene el vector de
dimensión del resultado. Tan si Un, B y C es todas las variedades similares, entonces
> D <- 2*Un*B + C + 1
Marcas D una variedad similar con su vector de dato siendo el resultado del elemento dado-
por-operaciones de elemento. Aun así la regla precisa respecto de vector y variedad mixtos
los cálculos tiene que ser considerados un poco más cuidadosamente.
5.4.1 Mixed vector y aritmética de variedad. La regla de reciclaje

La regla precisa que afecta elemento por elemento los cálculos mixtos con vectores y
variedades es un poco quirky y duros de encontrar en las referencias. De experimenta
hemos encontrado el siguiendo para ser una guía fiable.
• La expresión está escaneada de izquierdo a correcto..
• Cualesquier operandos de vector cortos están extendidos por reciclar sus valores hasta
que emparejan la medida de cualesquier otros operandos.
• Mientras variedades y vectores cortos sólo están encontrados, las variedades tienen que todo haber
igual
dim Atributo o unos resultados de error.
• Cualquier operando de vector más largo que un matricial u operando de variedad genera un error.
• Si estructuras de variedad son presentes y ningún error o coercion al vector ha sido
precipitado, el resultado es una estructura de variedad con el común dim atributo
de sus operandos de variedad.
matrices
5.5 TÉl producto exterior de dos variedades

Una operación importante en variedades es el producto exterior. Si un y b es dos
variedades numéricas, su producto exterior es una variedad cuyo vector de dimensión está
obtenido por concatenar sus dos vectores de dimensión (el orden es importante), y cuyo
vector de dato está conseguido por formar todos los productos posibles de elementos del
vector de dato de un con aquellos de b . El producto exterior está formado por el
operador especial o :
> ab <- Un o b
Una alternativa es
> ab <- Exterior(un, b, "*")
La función de multiplicación puede ser reemplazada por una función arbitraria de dos
variables. Por ejemplo si deseamos evaluar la función f (x; y) = cos(y)/(1 + x2) sobre una
verja regular de valores con x - y y -las coordenadas definieron por el R vectores x y y
respectivamente, podríamos proceder como sigue:.
> f <- Función(x, y) cos(y)/(1 + x^2)
> z <- Exterior(x, y, f)
En particular el producto exterior de dos vectores normales es un doblemente
subscripted variedad (aquello es una matriz , de rango como máximo 1). Aviso que el
operador de producto exterior es naturalmente no- commutative. Definiendo vuestro
propio R las funciones serán consideradas más allá en Capítulo 10 [Escribiendo vuestras
funciones propias], página 42.
Un ejemplo: Determinantes de 2 por 2 matrices de dígito solo

Cuando un artificial pero ejemplo lindo, considerar los determinantes de 2 por 2 matrices [un,
b; c, d] dónde cada entrada es un entero no negativo en la gama 0, 1, . . . , 9, aquello es un
dígito .
− anuncio bc, de todas las matrices posibles
El problema es para encontrar los determinantes,
de esta forma y representar la frecuencia con qué cada valor ocurre como parcela de
densidad alta. Estas cantidades a encontrar la distribución de probabilidad del determinante si
cada dígito está escogido independientemente y uniformemente al azar..
Una manera ordenada de hacer estos usos el exteriores() funciona dos veces:
> d <- Exterior(0:9, 0:9)
> fr <- Mesa(exterior(d, d, "-"))
> Parcela(fr, xlab="Determinante", ylab="Frecuencia")
Aviso que parcela() aquí utiliza a un histograma le gusta método de parcela, porque “ve”
que fr es de mesa "de clase". La “manera” obvia de hacer este problema con para bucles,
para ser hablados en Capítulo 9 [Bucles y ejecución condicional], página 40, es tan inefficient tan
para ser poco práctico.
Es también quizás sorprendiendo que aproximadamente 1 en 20 tales matrices es singulares.
5.6 Generalizado transpose de una variedad

La función aperm(un, perm) puede soler permute una variedad, un. El argumento perm
tiene que ser una permutación{ de los enteros
} 1, . . . , k , donde k es el número de subíndices en
un . El resultado de la función es una variedad de la misma medida como pero con la
dimensión vieja dada por perm[j] deviniendo el nuevo j-th dimensión. La manera más
fácil de pensar de esta operación es como generalización de transposición para matrices. De
hecho si Un es una matriz, (aquello es, un doblemente subscripted variedad) entonces B
dado por
> B <- aperm(Un, c(2,1))
Es justo el transpose de Un . Para este caso especial una función más sencilla t() es
disponible, así que podríamos haber utilizado B <- t(Un).
matrices
5.7 Matrix instalaciones

Cuando notó encima, una matriz es justo una variedad con dos subíndices. Aun así es tal un
caso especial importante necesita una discusión separada. R Contiene muchos operadores y
funciona aquello es disponible sólo para matrices. Por ejemplo t(X) es el matricial
transpose función, cuando notó encima. Las funciones nrow(Un) y ncol(Un) da el
número de filas y columnas en el matriciales Un respectivamente.
5.7.1 Materix multiplicación

El operador * Está utilizado para multiplicación matricial. Un n por 1 o 1 por n la matriz
naturalmente puede ser utilizada como un n-vector si en el contexto tal es apropiado. En
cambio, vectores qué ocurrir en expresiones de multiplicación matricial son automáticamente
promovidas tampoco para remar o vectores de columna, whichever es multiplicatively
coherente, si es posible, (a pesar de que esto no es siempre inequívocamente posible, cuando
vemos más tardíos).
Si, por ejemplo, Un y B es matrices cuadradas de la misma medida, entonces
> Un * B
Es la matriz de elemento por productos de elemento y
> Un * B
Es el producto matricial. Si x es un vector, entonces
> x * Un * x
Es una forma cuadrática.1
La función crossprod() forma “crossproducts”, significando que crossprod(X, y) es
el mismo tan t(X) * y Pero la operación es más eficaz. Si el segundo argumento a
crossprod() está omitido está tomado para ser igual como el primero.
El significado de diag() dep fines en su argument. diag(v), donde v es un vector,
gives una matriz diagonal con eleme nts de el vector tan t él diagonal enprueba. En el
otro ha nd diag(M), donde M es una matriz, gives the vector de diagonal principal enprueba
de M . Esto es el mismo convention como aquel utilizado para diag() en M UNTLAB.
También, un poco confusingly, si k es un solo numeric value entonces diag(k) es el k by k
identity matriz!
5.7.2 Ecuaciones lineales e inversion

Solucionando las ecuaciones lineales es el inverse de multiplicación matricial. Cuando después
> b <- Un * x
Sólo Un y b está dado, el vector x es la solución de aquel sistema de ecuación lineal. En R,
> Soluciona(Un,b)
Soluciona el sistema, regresando x (hasta alguna pérdida de exactitud). Nota que en álgebra lineal,
formalmente
x = Un−1b donde Un −1 denota el inverse de Un , los cuales pueden ser computados por
Soluciona(Un)
Pero raramente está necesitado. Numéricamente, es ambos inefficient y potencialmente inestable de
computar x
<- Solucionar(Un) * b En vez de solucionar(Un,b).
La forma cuadrática xT Un −1 x cuál está utilizado en multivariate computaciones, tendría
que ser computado por a algo le gusta2 x * Soluciona(Un,x), más que computar el
inverse de Un .
1
Nota que x * x es ambiguo, cuando pueda significar cualquier x T x o xxT , donde x es la forma
de columna. En tales casos la matriz más pequeña parece implícitamente para ser la interpretación
adoptó, así que el escalar x T x es en este caso el resultado. La matriz xxT puede ser calculado
cualquiera por cbind(x) * x o x * rbind(x) desde el resultado derbind() o cbind() es siempre una
matriz. Aun así, la manera mejor de computar x T x o xxT es crossprod(x) o x. o x
Respectivamente.
2
Incluso mejor sería para formar una raíz cuadrada matricial B con Un = BB T y encontrar la longitud
cuadrada del.
Solución de Por = x , quizás utilizando el Cholesky o eigen descomposición de Un .
matrices
5.7.3 Eigenvalues Y eigenvectors.

La función eigen(Sm) calcula el eigenvalues y eigenvectors de un symmetric matricial
Sm. El resultado de esta función es una lista de dos componentes nombraron valores y
vectores . La asignación
> ev <- eigen(Sm)
Asignará esta lista a ev . Entonces ev$val es el vector de eigenvalues de Sm y ev$vec es
la matriz de correspondiente eigenvectors. Tuvo sólo necesitamos el eigenvalues podríamos
haber utilizado la asignación:.
> evals <- eigen(Sm)$Valores
evals Ahora aguanta el vector de eigenvalues y el segundo componente es discarded. Si la
expresión
> eigen(Sm)
Está utilizado por él como mandar los dos componentes están imprimidos, con sus
nombres. Para matrices grandes es mejor de evitar computando el eigenvectors si no son
necesitados por utilizar la expresión.
> evals <- eigen(Sm, sólo.Los valores = CIERTOS)$valores
5.7.4 Descomposición de valor singular y determinantes.

La función svd(M) toma un argumento matricial arbitrario, M, y calcula la descomposición de
valor singular de M . Esto consta de una matriz de columnas ortonormales U con el mismo
espacio de columna cuando M , una segunda matriz de columnas ortonormales V de quién
espacio de columna es el espacio de fila de M y una matriz diagonal de entradas positivas D
tal aquello M = U * D * t(V). D es de hecho regresado como vector de los elementos
diagonales. El resultado de svd(M) es de hecho una lista de tres componentes nombró d, u y v
, con significados evidentes.
Si M es de hecho cuadrado, entonces, no es duro de ver aquello
> absdetM <- prod(svd(M)$d)
Calcula el valor absoluto de el determinante de M . Si este cálculo estuvo necesitado a
menudo con una variedad de matrices pueda ser definido como un R función
> absdet <- Función(M) prod(svd(M)$d)
Después de que cuál podríamos utilizar absdet() cuando justo otro R función. Como más
lejano trivial pero potencialmente ejemplo útil, te podría gustar considerar escribiendo una
función, dice tr(), para calcular el rastro de una matriz cuadrada. [Pista: no necesitarás
utilizar un bucle explícito. Mirada otra vez en el diag() función.]
R Tiene un builtin función det para calcular un determinante, incluyendo la señal, y otro,
Determinante, para dar la señal y modulus (opcionalmente encima escala de registro),
5.7.5 Lplazas del este que caben y el QR descomposición
La función lsfit() regresa una lista que da resultados de un menos cuadra caber
procedimiento. Una asignación como.
> ans <- lsfit(X, y)
Da los resultados de un menos cuadra cabido dónde y es el vector de observaciones y X es la
matriz de diseño. Ver la facilidad de ayuda para más detalles, y también para la función de
seguimiento ls.diag() Para, entre otras cosas, diagnósticos de regresión. Nota que un plazo
malo magnífico es automáticamente en- cluded y necesita no ser incluido explícitamente como
columna de X . Nota más lejana que te casi siempre preferirá utilizar lm(.) (Ve Sección 11.2
[modelos Lineales], página 54) a lsfit() para modelización de regresión.
Otro función relacionada estrechamente es qr() y sus aliados. Considerar las asignaciones siguientes
> Xplus <- qr(X)
matrices
> b <- qr.coef(Xplus, y)

> Acceso <- qr.Cabido(Xplus, y)
> res <- qr.resid(Xplus, y)
Estos computan el ortogonales projection de y ona la gama de X en cabido, el
projection ona el ortogonal complement en res y el c oefficient vector para el projection
en b , aquello es, b es essentially el resultado de t he MUNTLAB ‘backslash' operator.
No es supuesto que X tiene rango de columna llena. Las redundancias serán
descubiertas y sacadas cuando están encontrados.
Esta alternativa es el más viejo, abajo-manera de nivel para actuar menos cuadra
cálculos. A pesar de que todavía útil en algunos contextos, él ahora generalmente ser
reemplazado por las características de modelos estadísticas, cuando será hablado en
Capítulo 11 [modelos Estadísticos en R], página 51.
5.8 Forming partitioned Matrices, cbind() y rbind().

Cuando ya hemos visto informalmente, las matrices pueden ser construidas arriba de otros
vectores y matrices por las funciones cbind() y rbind() . Aproximadamente cbind()
forma matrices por matrices juntas obligatorias horizontalmente, o columna-sensato, y rbind()
verticalmente, o fila-sensato..
En la asignación
> X <- cbind(arg_1, arg_2, arg_3, ...)
Los argumentos a cbind() tiene que ser cualesquier vectores de cualquier longitud, o
matrices con la misma medida de columna, aquello es el mismo número de filas. El
resultado es una matriz con el concatenó argumentos arg 1, arg 2, . . . Formando las
columnas.
Si algunos de los argumentos a cbind() es vectores pueden ser más cortos que la medida de
columna de cualquier presente de matrices, en qué caso son cyclically extendidos para
emparejar la medida de columna matricial (o la longitud de el vector más largo si ninguna
matriz está dada).
La función rbind() la operación correspondiente para filas. En este caso cualquier
argumento de vector, posiblemente cyclically extendido, es naturalmente tomado tan vectores
de fila.
Supone X1 y X2 tiene el mismo número de filas. Para combinar estos por columnas a
una matriz X, junto con una columna inicial de 1 s podemos utilizar
> X <- cbind(1, X1, X2)
El resultado de rbind() o cbind() siempre tiene estado matricial. Por ello cbind(x) y rbind(x)
es posiblemente las maneras más sencillas explícitamente para dejar el vector x para ser tratado
como columna o matriz de fila respectivamente.
5.9 La función de concatenación, c(), con variedades.

Tenga que ser notado que mientras que cbind() y rbind() es la concatenación funciona
que respeto dim atributos, el básicos c() función no, sino aclara objetos numéricos de todo
dim y dimnames atributos. Esto es ocasionalmente útil en su derecho propio.
La manera oficial de coaccionar una variedad atrás a un objeto de vector sencillo es para utilizar
cuando.Vector()
> vec <- Cuando.Vector(X)
Aun así un resultado similar puede ser conseguido por utilizar c() con justo un
argumento, sencillamente para este lado-efecto:
> vec <- c(X)
Hay diferencias leves entre el dos, pero finalmente la elección entre ellos es en gran
parte un asunto de estilo (con el anterior siendo preferible).
matrices
5.10 Frequency Mesas de factores.

Recuerda que un factor define una partición a grupos. De modo parecido un par de factores
define una dos cruz de manera clasificación, y tan encima. La mesa de función() deja
mesas de frecuencia para ser calcu- lated de factores de longitud igual. Si hay k argumentos
de factor, el resultado es un k-variedad de manera de frecuencias.
Supone, por ejemplo, que statef es un factor que da el código estatal para cada entrada
en un vector de dato. La asignación
> statefr <- Mesa(statef)
Da en statefr una mesa de frecuencias de cada estado en la muestra. Las frecuencias
están ordenadas y etiquetados por el atributo de niveles del factor. Este caso sencillo es
equivalente a, pero más conveniente que,
> statefr <- tapply(statef, statef, longitud)
Más allá suponer que incomef es un factor que da un suitably clase “de ingresos
definidos” para cada entrada en el vector de dato, por ejemplo con el corte() función:
> Factor(corte(ingresos, rompe = 35+10*(0:7))) -> incomef
Entonces para calcular una mesa de dos maneras de frecuencias:
> Mesa(incomef,statef)
statef
incomef Act nsw nt qld sa tas vic wa
o
(35,45] 1 1 0 1 0 0 1 0
(45,55] 1 1 1 1 2 0 1 3
(55,65] 0 3 1 3 2 2 2 1
(65,75] 0 1 0 0 0 0 1 0
La extensión a mesas de frecuencia de manera alta es inmediata.
26
6 Lists Y marcos de dato
6.1 Lists
Un R la lista es un objeto constando de una colección ordenada de los objetos sabidos como sus
componentes.
hay no necesidad particular para los componentes para ser del mismo modo o tipo, y,
por ejemplo, una lista podría constar de un vector numérico, un valor lógico, una matriz,
un vector complejo, una variedad de carácter, una función, y tan encima. Aquí es un
ejemplo sencillo de cómo para hacer una lista:
> Lst <- Lista(nombre="Fred", mujer="Mary",
no.Niños=3, niño.Edades=c(4,7,9))
Los componentes son siempre numerados y siempre puede ser referido a como tal. Así si
Lst es el nombre de una lista con cuatro componentes, estos pueden ser individualmente
referidos a tan Lst[[1]], Lst[[2]], Lst[[3]] y Lst[[4]] . Si, más allá, Lst[[4]] es un
vector subscripted variedad entonces Lst[[4]][1] es su primera entrada.
Si Lst es una lista, entonces la longitud de función(Lst) da el número de (nivel
superior) componentes tiene.
Componentes de las listas también pueden ser nombradas, y en este caso el
componente puede ser referido a cualquiera por dar el nombre de componente como
cuerda de carácter en sitio del número en paréntesis cuadrados dobles, o, más
oportunamente, por dar una expresión de la forma
> Nombre$nombre_de componente
Para la misma cosa.
Esto es una convención muy útil cuando lo haga más fácil de conseguir el
componente correcto si olvidas el número.
Tan en el ejemplo sencillo dado encima:
Lst$El nombre es el mismo tan Lst[[1]] y es la cuerda
"Fred", Lst$la mujer es el mismo tan Lst[[2]] y es
la cuerda "Mary",
Lst$Niño.Edades[1] es el mismo tan Lst[[4]][1] y es el número 4.
Además, uno también puede utilizar los nombres de los componentes de lista en
paréntesis cuadrados dobles, i.e., Lst[["nombre"]] es el mismo tan Lst$nombre. Esto
es especialmente útil, cuándo el nombre de el componente para ser extraído está almacenado
en otro variable cuando en
> x <- "Nombre"; Lst[[x]]
Es v ery important a disting uish Lst[[1]] de Lst[1] . ‘[[...]]' Es el o perator usod
para seleccionar un solo element, mientras que ‘[...]' Es un general subscripting
operator. Thnos El anterior es el primer objeto en la lista Lst, y si es una lista nombrada
el nombre no es incluido. El último es un sublist de la lista Lst constando de la
primera entrada sólo. Si es una lista nombrada , los nombres están transferidos al
sublist.
Los nombres de componentes pueden ser abreviados abajo al número mínimo de letras
necesitó identificarles singularmente. Así Lst$los coeficientes pueden ser minimally
especificados como Lst$coe y Lst$covarianza como Lst$cov.
El vector de nombres es de hecho sencillamente un atributo de la lista como cualquier otro
y puede ser manejado como tal. Otras estructuras además las listas pueden, naturalmente, de
modo parecido ser dados unos nombres atribuyen también.
Capítulo 6: Listas y marcos de 27
dato
6.2 Construyendo y modificando listas

Las listas nuevas pueden ser formadas de existir objetos por la lista de función(). Una
asignación de la forma
> Lst <- Lista(nombre_1=objeto_1, ..., nombre_m=objeto_m)
Instala una lista Lst de m los componentes que utilizan objeto 1, . . . , objeto m para los
componentes y dándoles nombra tan especificado por los nombres de argumento, (cuáles
pueden ser libremente escogidos). Si estos nombres están omitidos, los componentes están
numerados sólo. Los componentes utilizaron para formar la lista está copiada cuándo
formando la lista nueva y los originales no son afectados.
Listas, como cualquier subscripted objeto, puede ser extendido por especificar
componentes adicionales. Por ejemplo.
> Lst[5] <- lista(Estera=matricial)
6.2.1 Concatenando listas

Cuándo la función de concatenación c() está dado argumentos de lista, el resultado es
un objeto de lista de modo también, cuyos componentes son aquellos de las listas de
argumento unieron juntas en secuencia.
> Lista.ABC <- c(Lista.Un, lista.B, lista.C)
Recuerda que con objetos de vector como argumentos la función de concatenación de
modo parecido unida junto todos los argumentos a una estructura de vector sola. En este
caso todos otros atributos, como dim atributos, es discarded.
6.3 Marcos de dato

Un marco de dato es una lista con dato "de clase.Marco". Hay restricciones en listas
que puede ser hecho a marcos de datos, concretamente
• Los componentes tienen que ser vectores (numéricos, carácter, o lógico), factores,
matrices numéricas, listas, u otros marcos de dato.
• Matrices, listas, y marcos de dato proporcionan tan muchas variables al marco de
dato nuevo cuando tienen columnas, elementos, o variables, respectivamente.
• Vectores numéricos, logicals y los factores están incluidos cuando 1es, y por default vectores de
carácter
Está coaccionado para ser factores, cuyos niveles son los valores únicos apareciendo en el vector.
• El vector estructura aparecer como variables del mosto de marco del dato todos tienen
la misma longitud, y las estructuras matriciales tienen que todos tienen la misma
medida de fila.
Un marco de dato puede para muchos propósitos ser considerados como matriciales
con columnas posiblemente de diferir modos y atributos. Pueda ser mostrado en forma
matricial, y sus filas y las columnas extrajeron utilizar convenciones de indexación
matricial.
6.3.1 Making marcos de dato

Los objetos que satisfacen las restricciones colocadas en las columnas (componentes) de
un marco de dato puede soler forma un utilizando el dato de función.Marco:
> Contables <- datos.Marco(casa=statef, loot=ingresos, disparó=incomef)
Una lista cuyos componentes conforman a las restricciones de un marco de dato pueden ser
coaccionadas a un marco de dato que utiliza la función cuando.Dato.Marco()
La manera más sencilla de construir un marco de dato de arañazo es para utilizar el
leído.Mesa() función para leer un marco de dato entero de un archivo externo. Esto está
hablado más allá en Capítulo 7 [Leyendo dato de archivos], página 30.
1
Conversión de columnas de carácter a factores es overridden utilizando el stringsAsFactors argumento al
Dato.Marco() función.
dato
6.3.2 Sujeta() y detach().

El $ notación, como contables$en casa, para componentes de lista no es siempre muy
convenientes. Una facilidad útil sería de alguna manera para hacer los componentes de una lista o
marco de dato temporalmente visible como variables bajo su nombre de componente, sin la
necesidad de citar el nombre de lista explícitamente cada vez..
El sujetar() la función toma una ‘base de datos' como una lista o marco de dato como su
argumento. Así suponer las lentejas es un marco de dato con tres lentejas de
variables$u, lentejas$v, lentejas$w. El sujetar
> Sujeta(lentejas)
Sitios el marco de dato en el camino de búsqueda en posición 2, y proporcionado no hay
ninguna variable u, v o w en posición 1, u, v y w es disponible como variables del
marco de dato en su derecho propio. Al llegar a este punto una asignación como.
> u <- v+w
No reemplaza el componente u del marco de dato, sino máscaras él con otro variable u
en el directorio laborable en posición 1 en el camino de búsqueda. Para hacer un cambio
permanente a el dato enmarca él, la manera más sencilla es para recurrir una vez más a
el $ notación:
> Lentejas$u <- v+w
Aun así el valor nuevo de componente u no es visible hasta el marco de dato es
detached y sujetó otra vez.
A detach un marco de dato, uso la función.
> detach()
Más precisamente, esta declaración detaches de el camino de búsqueda la entidad
actualmente en posición 2. Así en el contexto presente las variables u, v y w sería ya no
visible, exceptúa bajo la notación de lista como lentejas$u y tan encima. Entidades en
las posiciones más grandes que 2 en el camino de búsqueda puede ser detached por dar su
número a detach , pero es mucho más seguro a siempre utilizar un nombre, por ejemplo por
detach(lentejas) o detach( "lentejas")
Nota: En R listas y marcos de dato sólo pueden ser sujetados en posición 2 o
encima, y qué está sujetado es una copia del objeto original. Puedes alterar el
sujetó valores vía asignar, pero la lista original o marco de dato es sin
cambios.
6.3.3 Working Con marcos de datos
Una convención útil que te dejas para trabajar con muchos los problemas diferentes
cómodamente juntos en el mismo directorio laborable es
• Reúne junto todas las variables para cualquier problema bien definido y separado en
un marco de dato bajo un suitably nombre informativo;
• Cuándo trabajando con un problema sujeta el marco de dato apropiado en posición 2,
y utilizar el directorio laborable en nivel 1 para cantidades operacionales y variables
provisionales;
• Antes de dejar un problema, añadir cualesquier variables deseas mantener para
referencia futura al marco de dato que utiliza el $ forma de asignación, y entonces
detach();
• Finalmente sacar todas las variables indeseadas del directorio laborable y mantenerlo
tan limpio de izquierdo-sobre variables provisionales como posibles.
De este modo es bastante sencillo de trabajar con muchos problemas en el mismo
directorio, todo del cual tiene las variables nombraron x, y y z , por ejemplo.
6.3.4 Unttaching listas arbitrarias

Sujeta() es una función genérica que deja no dato y directorios únicos marcos para
ser sujetados a el camino de búsqueda, pero otras clases de objetar también. En
particular cualquier objeto de lista "de modo" puede ser sujetado en la misma manera:
dato
> Sujeta(cualquiera.Viejo.Lista)
Cualquier cosa aquello ha sido sujetado puede ser detached por detach, por número de
posición o, preferir- ably, por nombre.
6.3.5 Managing el camino de búsqueda

La búsqueda de función muestra el camino de búsqueda actual y así que es una manera
muy útil para mantener pista del cual marcos de datos y listas (y paquetes) ha sido sujetado y
detached. Inicialmente da
> Búsqueda()
[1] ".GlobalEnv" "Autoloads" "Paquete:base"
Dónde .GlobalEnv Es el
workspace.2 Después de que las
lentejas está sujetada nosotras
tiene
> Búsqueda()
[1] ".GlobalEnv" "Lentejas" "Autoloads" "paquete:base"
> ls(2)
[1] "u" "v" "w"
Y cuando vemos ls (u objetos) puede soler examinar los contenidos de cualquier
posición en el camino de búsqueda.
Finalmente, nosotros detach el marco de dato y confirmarlo ha sido sacado del camino de búsqueda.
> detach("Lentejas")
> Búsqueda()
[1] ".GlobalEnv" "Autoloads" "Paquete:base"
2
Ve la ayuda on-line para autoload para el significado del segundo plazo.
30
7 Leyendo dato de archivos.

Objetos de dato grande normalmente serán leídos como valores de archivos externos
más que introducidos durante un R sesión en el teclado. R Instalaciones de entrada son
sencillas y sus requisitos son bastante estrictos e incluso bastante inflexible. Hay una
presunción clara por los diseñadores de R que te será capaz de modificar vuestra entrada
archiva utilizar otras herramientas, como editores de archivo o Perl 1 para caber en con
los requisitos de R. Generalmente esto es muy sencillo.
Si las variables son para ser aguantados principalmente en marcos de datos, cuando
fuertemente sugerimos tendrían que ser, un marco de dato entero puede ser leído directamente
con el leído.Mesa() función. hay también una entrada más primitiva función,
escáner(), aquello se puede apellidar directamente.
Para más detalles en dato importador a R y también dato exportador, ver el R Dato Im-
manual/de Exportación portuaria.
7.1 T Lea.Mesa() función

Para leer un marco de dato entero directamente, el archivo externo normalmente tendrá una forma
especial.
• La primera línea de el archivo tendría que tener un nombre para cada variable en el marco de
dato.
• Cada línea adicional del archivo tiene como su primer elemento una etiqueta de fila y
los valores para cada variable.
Si el archivo tiene uno menos elemento en su primera línea que en su segundo, este
arreglo es presumed para estar vigente. Así que el primeras pocas líneas de un archivo
para ser
, leído como marco de datos podría mirar como sigue.. ,
Forma de archivo de la entrada con nombres y etiquetas de fila:
Precio Piso Área Habit Edad Céntimo.C
acion alor
es
01 52.00 111.0 830 5 6.2 Núm
02 54.75 128.0 710 5 7.5 Núm
03 57.50 101.0 1000 5 4.2 Núm
04
... 57.50 131.0 690 6 8.8 Núm
\ 05 59.75 93.0 900 5 1.9 Sí J
Por default elementos numéricos (exceptúa etiquetas de fila) está leído como variables
numéricas y variables no numéricas, como Céntimo.Calor en el ejemplo, cuando factores.
Esto puede ser cambiado si es necesario.
La función leyó.Mesa() entonces puede soler leído el marco de dato directamente
> HousePrice <- Leído.Mesa("casas.Dato")
A menudo querrás omitir incluyendo las etiquetas de fila directamente y utilizar el default
etiquetas. En
, el archivo puede omitir la columna de etiqueta de la fila cuando en el siguiente.
Este caso ,
Forma de archivo de la entrada sin etiquetas de fila:

Precio Piso Área Habit Edad Céntimo.Calor
acion
es
52.00 111.0 830 5 6.2 Núm
54.75 128.0 710 5 7.5 Núm
57.50 101.0 1000 5 4.2 Núm
57.50
... 131.0 690 6 8.8 Núm
\ 59.75 93.0 900 5 1.9 Sí J
1
Debajo UNIX, las utilidades sed orawk puede ser utilizado.
Capítulo 7: Leyendo dato de 31
archivos
El marco de dato entonces puede ser leído cuando

> HousePrice <- Leído.Mesa("casas.Dato", el encabezamiento=CIERTO)
Dónde el encabezamiento=la opción CIERTA especifica que la primera línea es
una línea de headings, y de ahí, por implicación de la forma del archivo, que no
etiquetas de fila explícita están dadas.
7.2 T Escanee() función

Suponer los vectores de dato son de longitud igual y es para ser leído en paralelo. Más allá
suponer que hay tres vectores, el primer de carácter de modo y el restante dos del modo
numérico, y el archivo es entrada .dat. El primer paso es para utilizar escáner() para leer
en los tres vectores como lista, como sigue.
> inp <- Escáner("entrada.dat", lista("",0,0))
El segundo argumento es un dummy la lista estructura aquello establece el modo de
los tres vectores para ser leídos. El resultado, aguantado en inp, es una lista cuyos
componentes son los tres vectores leídos en. Para separar los elementos de dato a tres
vectores separados, a asignaciones de uso les gusta
> Etiqueta <- inp[[1]]; x <- inp[[2]]; y <- inp[[3]]
Más oportunamente, el dummy la lista puede tener nombró componentes, en qué caso
los nombres pueden soler acceder los vectores leídos en. Por ejemplo.
> inp <- Escáner("entrada.dat", lista(id="", x=0, y=0))
Si deseas acceder las variables por separado tampoco pueden ser re-asignados a variables
en el marco laborable:
> Etiqueta <- inp$id; x <- inp$x; y <- inp$y
O la lista puede ser sujetada en posición 2 de el camino de búsqueda (ve Sección 6.3.4
[Sujetando listas arbitrarias], página 28).
Si el segundo argumento es un valor solo y no una lista, un vector solo está leído en,
todos los componentes de los cuales tienen que ser del mismo modo como el dummy
valor.
> X <- matricial(escáner("ligero.dat", 0), ncol=5, byrow=CIERTO)
hay más elaborar instalaciones de entrada disponibles y estos están detallados en los manuales.
7.3 Accessing builtin datasets

Alrededor 100 datasets está suministrado con R (en paquete datasets), y otros son
disponibles en paquetes (incluyendo los paquetes recomendables suministraron con R). Para
ver la lista de datasets actualmente uso disponible
Dato()
Todo el datasets suministró con R es disponible directamente por nombre. Aun así, muchos
paquetes todavía utilizan la convención obsoleta en qué dato era también utilizado para
cargar datasets a R, por ejemplo.
Dato(infert)
Y esto todavía puede ser utilizado con los paquetes estándares (cuando en este ejemplo).
En más casos esto cargará un R objeto de el mismo nombre. Aun así, en unos cuantos
casos carga varios objetos, así que ve la ayuda on-line para el objeto para ver qué para
esperar.
7.3.1 Cargando dato de otro R paquetes
Para acceder dato de un paquete particular, uso el argumento de paquete, por ejemplo
Dato(paquete="rpart")
dato(Puromycin, paquete="datasets")
Si un paquete ha sido sujetado por biblioteca, su datasets es automáticamente
incluido en la búsqueda.
Usuario-contribuyó los paquetes pueden ser una fuente rica de datasets.
Capítulo 7: Leyendo dato de 32
archivos
7.4 Editing Dato

Cuándo invocado en un marco de dato o matriz, edita trae arriba de un separado
spreadsheet-gustar entorno para editar. Esto es útil para hacer cambios pequeños una vez
un conjunto de dato ha sido leído. La orden.
> xnew <- Editar(xold)
Te dejará para editar vuestro conjunto de dato xold, y encima conclusión el objeto
cambiado está asignado a xnew . Si quieres alterar el original dataset xold, la manera más
sencilla es para utilizar fijar(xold), el cual es equivalente a xold <- editar(xold).
Uso
> xnew <- Editar(dato.Marco())
Para introducir dato nuevo vía el spreadsheet interfaz.
33
8 ProbDistribuciones de capacidad
8.1 R Como puesto de mesas estadísticas

Uno uso conveniente de R es para proporcionar un conjunto comprensible de mesas
estadísticas. Las funciones están proporcionadas para evaluar≤la función de distribución
acumulable P (X x), la función de densidad de la probabilidad y el quantile función
≤
(dado q, el más pequeño x tal que P (X x) > q), y para simular de la distribución.
Distribución R Nombre Argumentos

adicionales
Beta Beta Forma1, forma2, ncp
Binomial binom Medida, prob
Cauchy cauchy Ubicación, escala
chi-Cuadró chisq df, ncp
Exponencial exp Índice
F f df1, df2, ncp
gamma gamma Forma, escala
Geométrico geom prob
hypergeometric hyper m, n, k
Registro-normal lnorm meanlog, sdlog
logistic logis Ubicación, escala
Binomio negativo nbinom Medida, prob
Normal Norma Malo, sd
Poisson pois Lambda
Rango firmado signrank n
Estudiantil t t df, ncp
Uniforme unif min, max
Weibull weibull Forma, escala
Wilcoxon wilcox m, n
Prefijo el nombre given aquíb y ‘d' para el density, ‘p' para el CDF, ‘q' para el
quanfunción de azulejo y ‘ r' para simulation (r andom deviates). El primer argument es
x parad xxx, q para pxxx, p para qxxx y n para r xxx (excepto rhyper, rsignrank y
rwilcox , para qué es nn). En no bastante todos los casos es el no-centrality parámetro ncp
actualmente disponible: ver la ayuda on-line para detalles.
El pxxx y q xxx funciona todos tienen los argumentos lógicos bajan.Cola y registro.p
Y el d xxx unos tienen registro. Esto deja, p. ej., consiguiendo el acumulable (o “integrado”)
hazard función, H(t) = − registro(1 − F (t)), por
- pxxx(t, ..., más bajo.La cola = FALSA, registro.p = CIERTO)
O registro más cuidadoso-likelihoods (por d xxx(..., el registro = CIERTO)), directamente.
Además hay funciones ptukey y qtukey para la distribución del studentized gama de
muestras de una distribución normal, y dmultinom y rmultinom para el multinomial
distribución. Las distribuciones más lejanas son disponibles en contribuyó paquetes, notablemente
SuppDists (https://cran.r-project.org/package=suppdists).
Aquí es algunos ejemplos
> ## 2-tailed p-valor para t distribución
> 2*pt(-2.43, df = 13)
> ## Superior 1% punto a favor un F(2, 7) distribución
> qf(0.01, 2, 7, más bajo.La cola = FALSA)
Ver la ayuda on-line en RNG para cómo generación de número aleatorio está hecha en R.
Capítulo 8: distribuciones de 34
Probabilidad
8.2 Examining La distribución de un conjunto de datos

Dado un (univariate) puesto de datos podemos examinar su distribución en un número grande de
maneras. El más sencillo es para examinar los números. Dos resúmenes ligeramente diferentes
están dados por resumen y fivenum y un displuny de eln umbers by raíz (una “raíz y lea
f” parcela).
> Sujeta(fiel)
> Resumen(erupciones)
Min. 1.º Qu. Median Malo 3.º Qu. Max.
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
> Raíz(erupciones)
El punto decimal es 1 dígito (s) a la izquierda
de el | 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 | 0000003357788888002233555577778
42 | 03335555778800233333555577778
44 | 02222335557780000000023333357778888
46 | 0000233357700000023578
48 | 00000022335800333
50 | 0370
Una raíz-y-parcela de hoja es como un histograma, y R tiene una función hist a histogramas de
parcela.
> hist(Erupciones)
## Marca los cubos más pequeños, marca una parcela de densidad
> hist(Erupciones, seq(1.6, 5.2, 0.2), prob=CIERTOS)
> Líneas(densidad(erupciones, bw=0.1))
> Alfombra(erupciones) # muestra los puntos de dato reales
Densidad más elegante las parcelas pueden ser hechas por densidad, y añadimos una
línea producida por
Densidad en este ejemplo. El ancho de banda bw estuvo escogido por prueba-y-error como
el default da
Probabilidad
Demasiado suavizando (normalmente hace para “densidades” interesantes). (Mejor automatizó

los métodos de elección de ancho de banda son disponibles, y en este ejemplo bw = "SJ" da
un resultado bueno.)
Histograma de erupciones
0.7
0.6
0.5
Frecuencia relativa
0.4
0.3
0.2
0.1
0.0
1.5 2.0 2.5 3.0 3.5 4.0 4.5 5.0
Erupciones
Podemos parcela la función de distribución acumulable empírica por utilizar la función ecdf.
> Parcela(ecdf(erupciones), .Los puntos=FALSOS, verticals=CIERTOS)
Esta distribución es evidentemente lejos de cualquier distribución estándar. Qué sobre
el modo derecho, decir erupciones de más largos que 3 minutos? Dejado nos cabido una
distribución normal y overlay el cabido CDF.
> Mucho tiempo <- erupciones[erupciones > 3]
> Parcela(ecdf(largo), .Los puntos=FALSOS, verticals=CIERTOS)
> x <- seq(3, 5.4, 0.01)
> Líneas(x, pnorm(x, malos=malos(largos), sd=sqrt(var(largos))), lty=3)
ecdf(Largo)
1.0
0.8
0.6
Fn(x)
0.4
0.2
0.0
3.0 3.5 4.0 4.5 5.0
Quantile-quantile (Q-Q) Las parcelas nos pueden ayudar examinar esto más cuidadosamente.
par(pty="s") # Arregla para una región de
figura cuadrada qqnorm(largo); qqline(largo)
Probabilidad
Cuál muestra una acceso razonable pero la cola correcta más a escasa que uno esperarían
de una distribución normal. Dejado nos comparar esto con algunos dato simulado de un t
distribución
Normal Q−Q Parcela

5.0
4.5
Muestra Quantiles
4.0
3.5
3.0
−2 −1 0 1 2
Teórico Quantiles
x <- rt(250, df = 5)
qqnorm(x); qqline(x)
Cuál normalmente (si es una muestra aleatoria ) muestra colas más largas que esperados
para un normales. Podemos hacer un Q-Q parcela contra la distribución de generar por
qqplot(qt(ppoints(250), df = 5), x, xlab = "Q-Q parcela para t
dsn") qqline(x)
Finalmente, podríamos querer una prueba más formal de acuerdo con normalidad (o
no). R Proporciona el Shapiro-Wilk prueba
> shapiro.Prueba(largo)
Shapiro-Wilk Dato de prueba
de la normalidad: mucho tiempo

W = 0.9793, p-valor = 0.01052
Y el Kolmogorov-Smirnov prueba
> ks.Prueba(mucho tiempo, "pnorm", malo = malo(largo), sd = sqrt(var(largo)))
Uno-muestra Kolmogorov-Smirnov
dato de prueba: mucho tiempo

D = 0.0661, p-valor = 0.4284
Hipótesis alternativa: dos.sided
(Nota que la teoría de distribución no es válida aquí cuando hemos estimado los
parámetros de la distribución normal de la misma muestra.)
8.3 Uno- y pruebas de dos muestras

Tan lejos hemos comparado una muestra sola a una distribución normal. Una operación
mucho más común es para comparar aspectos de dos muestras. Nota que en R, todo “las
pruebas” clásicas que incluyen los utilizaron abajo es en paquete stats cuál es normalmente
cargado.
Considerar los conjuntos siguientes de datos en el calor latente de la fusión de hielo
(cal/gm) de Arroz (1995, p.490)
Probabilidad
Método Un: 80.04 80.02 80.04 80.03 80.03 80.04 79.97

79.98
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
Boxplots Proporciona una comparación gráfica sencilla de las dos muestras.
Un <- escáner()
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 <-
Escáner() 79.98 79.97 79.97 80.03 79.95 79.97
80.02 79.94
boxplot(Un, B)
Cuál indica que el primer grupo tiende para dar resultados más altos que el segundo.
79.98 80.0280.00 80.04
79.96
79.94
1 2
Para probar para la igualdad del medio de los dos ejemplos, podemos utilizar un unpaired t-prueba
por
> t.Prueba(Un, B)
Welch Dos Muestra t-
dato de prueba: Un y B.
t = 3.2499, df = 12.027, p-valor = 0.00694
Hipótesis alternativa: diferencia cierta en los medios no es iguales a 0
95 confianza de porcentaje intervalo:
0.01385526 0.07018320
Estimaciones de muestra:
Malo de x malo
de y 80.02077
79.97875
which does Indica un significant diferencia, suponiendo normality. Por default el R
function does no suponer equality de v ariances en el t wo muestras (en co ntrast a el
similares S-MÁS t.Función de prueba). We Puede utilizar el F prueba para probar
para equality en el variances, provided que el t wo las muestras son de normales
populations.
> var.Prueba(Un, B)
F Prueba para comparar dos varianzas

Probabilidad
Dato: Un y B.
F = 0.5837, num df = 12, denom df = 7, p-valor = 0.3938
hipótesis alternativa: proporción cierta de las varianzas no es
iguales a 1.
0.1251097 2.1052687
Proporción de varianzas.
0.5837405
Cuál No muestra ninguna evidencia de una diferencia significativa, y tan podemos utilizar el
clásicos t-probar aquello supone igualdad de las varianzas.
> t.Prueba(Un, B, var.Igual=CIERTO)
Dos Muestra t-
dato de prueba: Un y
B.
t = 3.4722, df = 19, p-valor = 0.002551
Hipótesis alternativa: diferencia cierta en los medios no es iguales a 0
0.01669058 0.06734788
Malo de x malo
de y 80.02077
79.97875
Todas estas pruebas suponen normalidad de las dos muestras. El dos-muestra
Wilcoxon (o Mann- Whitney) prueba sólo supone una distribución continua común bajo
el null hipótesis.
> wilcox.Prueba(Un, B)
Wilcoxon Prueba de suma del rango con dato de
corrección de la continuidad: Un y B.
W = 89, p-valor = 0.007497
Hipótesis alternativa: cambio de ubicación cierta no es igual a 0
Advirtiendo mensaje:
No puede computar exacto p-valor con lazos en: wilcox.Prueba(Un, B)
Nota el aviso: hay varios lazos en cada muestra, el cual sugiere fuertemente que este
dato es de una distribución discreta (probablemente debido a redondear)..
Hay varias maneras de comparar graphically las dos muestras. Ya hemos visto un par
de boxplots. El siguiente
> Parcela(ecdf(Un), .Los puntos=FALSOS, verticals=CIERTOS, xlim=gama(Un, B))
> Parcela(ecdf(B), .Los puntos=FALSOS, verticals=CIERTOS, añade=CIERTO)
Mostrará el dos empírico CDFs, y qqplot actuará un Q-Q parcela de las dos muestras. El
Kolmogorov-Smirnov la prueba es de la distancia vertical máxima entre el dos ecdf es,
suponiendo una distribución continua común:
> ks.Prueba(Un, B)
Dos-muestra Kolmogorov-Smirnov
dato de prueba: Un y B.
D = 0.5962, p-valor = 0.05919
Probabilidad
Hipótesis alternativa: dos-sided
39
Advirtiendo mensaje:
No puede computar correcto p-valores con lazos en: ks.Prueba(Un, B)
40
9 Grouping, bucles y ejecución condicional
9.1 Grouped Expresiones

R Es una lengua de expresión en el sentido que su tipo de orden único es una función o
expresión qué regresos un resultado. Incluso una asignación es una expresión cuyo
resultado es el valor asignó, y pueda ser utilizado wherever cualquier expresión puede
ser utilizada; en particular las asignaciones múltiples son posibles.
Las órdenes pueden ser agrupadas juntos en tirantes, {expr_1; ...; expr_m}, en qué
caso el valor del grupo es el resultado de la última expresión en el grupo evaluó. Desde tal grupo
es también una expresión pueda, por ejemplo, ser él incluido en paréntesis y utilizados tan parte
de una expresión incluso más grande, y tan encima.
9.2 Control Declaraciones

9.2.1 Ejecución condicional: si declaraciones
La lengua tiene disponible una construcción condicional de la forma
> Si (expr_1) expr_2 más expr_3
Dónde expr 1 tiene que evaluar a un valor lógico solo y el resultado de la expresión
entera es entonces evidente.
Los “operadores de circuito” corto && y || es a menudo utilizado tan parte de la condición en
un si declaración. Mientras que & y | aplicar elemento-sensato a vectores, && y || aplicar a
vectores de longitud un, y sólo evaluar su segundo argumento si es necesario.
hay un vectorized version de el si/más construir, el ifelse función. Esto tiene la
forma ifelse(condición, un, b) y regresa un vector de la misma longitud cuando
condición, con elementos un[i] si condición[i] es cierto, otherwise b[i] (dónde un y b
está reciclado como necesario).
9.2.2 Repetitive Ejecución: para bucles, repite y mientras.

hay también un para construcción de bucle qué tiene la forma
> Para (nombre en expr_1) expr_2
Dónde el nombre es la variable de bucle . expr 1 es una expresión de vector, (a menudo a
una secuencia le gusta 1:20), y expr 2 es a menudo una expresión agrupada con su sub-las
expresiones escritas en plazos del dummy nombre. expr 2 es repetidamente evaluado tan
gamas de nombre a través de los valores en el resultado de vector de expr 1.
Cuando un ejemplo, supone ind es un vector de indicadores de clase y nosotros desean
producir parcelas separadas de y versus x dentro de clases. Una posibilidad aquí es para
utilizar coplot(),1 cuál producirá una variedad de las parcelas que corresponden a cada
nivel del factor. Otra manera de hacer este, ahora poniendo todas las parcelas encima el
muestra, es como sigue:.
> xc <- Ruptura(x, ind)
> yc <- Ruptura(y, ind)
> Para (i en
1:longitud(yc)) {
parcela(xc[[i]],
yc[[i]])
abline(lsfit(xc[[i]], yc[[i]]))
}
(Nota la ruptura de función() cuál produce una lista de vectores obtuvo por partir un
vector más grande según las clases especificó por un factor. Esto es una función útil ,
mayoritariamente utilizado en conexión con boxplots. Ver la facilidad de ayuda para
detalles más lejanos.)
1
para ser hablado más tarde, o uso xyplot de enrejado de paquete (https://cran.r-project.org/package=lattice).
Capítulo 9: Agrupación, bucles y ejecución 41
condicional
Aviso: para() los bucles están utilizados en R código mucho menos a menudo que
en compiló lenguas. Código que toma un ‘objeto entero' la vista probablemente puede
ser ambos más claro y más rápido en R.
Otro looping las instalaciones incluyen el
> Repite expr
Declaración y el
> Mientras (condición) expr
Declaración.
La declaración de rotura puede soler rescindir cualquier bucle, posiblemente
anormalmente. Esto es la manera única de rescindir repetir bucles.
La declaración próxima puede soler interrumpir uno ciclo particular y skip a el
“próximo”. Declaraciones de control son más a menudo utilizados en conexión con
funciones qué está hablado en
Capítulo 10 [Escribiendo vuestras funciones propias], página 42, y donde más ejemplos emergerán.
42
10 Writing Vuestras funciones propias

Cuando hemos visto informalmente a lo largo de la manera, el R la lengua deja el
usuario para crear objetos de función de modo. Estos son ciertos R funciona aquello está
almacenado en una forma interna especial y puede ser utilizado en expresiones más
lejanas y tan encima. En el proceso, los beneficios de lengua enormemente en poder,
comodidad y elegancia, y aprendiendo para escribir las funciones útiles es una de las
maneras principales de hacer vuestro uso de R cómodo y productivo..
Tenga que ser enfatizado que la mayoría de las funciones suministró tan parte del R
sistema, como malo(), var(), posdata() y tan encima, los es escrito en R y así no
difiere materially del usuario escrito funciona.
Una función está definida por una asignación de la forma
> Nombre <- función(arg_1, arg_2, ...) Expresión
La expresión es un R expresión, (normalmente una expresión agrupada), aquello utiliza los argumentos,
arg i, para calcular un valor. El valor de la expresión es el valor regresado para la función.
Una llamada a la función entonces normalmente toma el nombre de forma(expr_1,
expr_2, ...) Y puede ocurrir anywhere una llamada de función es legítima.
10.1 Ejemplos sencillos

Como primer ejemplo, considerar una función para calcular la dos muestra t-statistic,
mostrando “todos los pasos”. Esto es un ejemplo artificial , naturalmente, desde entonces
hay otro, maneras más sencillas de conseguir el mismo fin.
La función está definida como sigue:
> twosam <- Función(y1, y2) {
n1 <- longitud(y1); n2 <-
longitud(y2) yb1 <- malo(y1);
yb2 <- malo(y2) s1 <-
var(y1); s2 <- var(y2)
s <- ((n1-1)*s1 + (n2-1)*s2)/(n1+n2-2)
tst <- (yb1 - yb2)/sqrt(s*(1/n1 + 1/n2))
tst
}
Con esta función definió, podrías actuar dos muestra t-las pruebas que utilizan una llamada como
> tstat <- twosam(Dato$macho, dato$hembra); tstat
Como segundo ejemplo, considerar una función a e mulate directamente el M
UNTLAB backslash com- mand, which regresa the coefficients de el orthogonal projection
de el vector y ona el espacio de columna de la matriz, X. (Esto es normalmente
llamado t he menos cuadra estimación de la regresión coefficients.) Este w ould
normalmente be hecho con el qr() función; however esto es a veces un b él tricky para
utilizar directamente y él punys a h unve una función sencilla such como el folloala para
utilizarlo safely.
Thnos given Un n by 1 vector y y un n by p matriz X entonces X y está definido
cuando (X T X)− X T y, dónde (X T X)− es un generalizado inverse de X J X.
> bslash <- Función(X, y) {
X <- qr(X)
qr.coef(X, y)
}
Después de este objeto está creado lo puede ser utilizado en declaraciones como
> regcoeff <- bslash(Xmat, yvar)
Y tan encima.
Capítulo 10: Escribiendo vuestras 43
funciones propias
El clásico R función lsfit() este trabajo bastante bien, y más 1. Él en vuelta utiliza las
funciones qr() y qr.coef() En el ligeramente counterintuitive manera encima para hacer
esta parte del cálculo. De ahí hay probablemente algún valor en habiendo justo esto separa
aislado en un sencillo de utilizar función si va a ser en uso frecuente. Si tan, podemos
desear hacer lo un operador binario matricial para aún más uso conveniente.
10.2 Defining operadores binarios nuevos

Tuvo nosotros dados el bslash() funciona un nombre diferente, concretamente uno de la forma
Cualquier cosa
Pueda haber sido utilizado como operador binario en expresiones más que en forma de
función. Supone, por ejemplo, escogemos ! Para el carácter interno. La definición de
función entonces empezaría cuando
> " ! " <- Función(X, y) { ... }
(Nota el uso de citar marcas.) La función entonces podría ser utilizada cuando X !
y. (El backslash símbolo él no es una elección conveniente cuando presenta problemas
especiales en este contexto.)
El operador de multiplicación matricial, * , y el producto exterior operador
matricial o Esotros ejemplos de operadores binarios definieron de este modo..
10.3 Nombró argumentos y defaults

Tan primero notado en Sección 2.3 [Generando secuencias regulares], página 8, si
argumentos a llamados funciona está dado en la “forma=de objeto” del nombre, pueden
ser dados en cualquier orden. Además la secuencia de argumento puede empezar en el
unnamed, forma posicional, y especificar nombró argumentos después de los argumentos
posicionales.
Así si hay una diversión de función1 definido por
> Divertido1 <- función(dato, dato.Marco, graph, límite) {
[Cuerpo de función omitido]
}
Entonces la función puede ser invocada en varias maneras, por ejemplo.
> ans <- Divertido1(d, df, CIERTO, 20)
> ans <- Divertido1(d, df, graph=CIERTO, límite=20)
> ans <- Divertido1(dato=d, límite=20, graph=CIERTO, dato.Marco=df)
Es todo equivalente.
En muchos argumentos de casos pueden ser dados generalmente apropiados default
valores, en qué caso pueden ser omitidos altogether de la llamada cuándo el defaults es
apropiado. Por ejemplo, si diversión1 estuvo definido cuando
> Divertido1 <- función(dato, dato.Marco, graph=CIERTO, límite=20) { ... }
se pueda apellidar cuando
> ans <- Divertido1(d, df)
Cuál es ahora equivalente a los tres casos encima, o cuando
> ans <- Divertido1(d, df, límite=10)
Cuál cambia uno del defaults.
Es importante de notar que defaults puede ser expresiones arbitrarias, incluso
implicando otros argumentos a la misma función; no son restringidos para ser
constantes tan en nuestro ejemplo sencillo aquí.
1
Ve también los métodos describieron en Capítulo 11 [modelos Estadísticos en R], página 51
funciones propias
10.4 TÉl ‘...' Argumento

Otro requisito frecuente es para dejar uno funciona para pasar encima encuadres de
argumento a otro. Por ejemplo muchas funciones de gráfico utilizan la función par() y a
funciones les gusta la parcela() deja el usuario para pasar en parámetros gráficos a par()
para controlar la producción gráfica. (Ve Sección 12.4.1 [El par() función], página 68, para
más detalles en el par() función.) Esto puede ser hecho por incluir un extra argument,
literalmente ‘...', de la función, which muny entonces be pasó encima. Un ejemplo de
esbozo está dado abajo.
Divertido1 <- función(dato, dato.Marco, graph=CIERTO, límite=20, ...) {
[Omitió declaraciones]
Si (graph)
par(pch="*", ...)
[Más omisiones]
}
Menos frequently, una función necesitará referir a comp ene nts de ‘ ...'. El e
xpres sion lista(...) Evalúa todos tales argumentos y les regresa en una lista nombrada,
mientras ..1, ..2, etc. evaluate les uno a la vez, con ‘ ..n' Regresando el n'th unmatched
argument.
10.5 Unssignments dentro de funciones.

Nota que cualesquier asignaciones normales hechas dentro de la función es local y
provisional y está perdido después de que salida de la función. Por ello la asignación X
<- qr(X) no afecta el valor del argumento en el programa de llamar..
Para entender completamente las reglas que gobiernan el alcance de R asignaciones
las necesidades de lector para ser familiares con la idea de un marco de evaluación.
Esto es un un poco adelantado, aun así difícilmente difícil, tema y no es cubierto más allá
aquí.
Si global y p ermanent assignments es i ntendió dentro de una función, entonces
cualquiera el “su- perassignment” operator, <<- o t he la función asigna() puede be utilizó.
Ver la ayuda document para detalles. S-MÁS los usuarios tienen que be unw es t hen <<-
ha different semunntics en R. Estos están hablados más allá en Sección 10.7 [Scope], página
46.
10.6 Mmena adelantó ejemplos

10.6.1 Efficiency Factores en diseños de bloque
Como más completo, si un poco peatón, ejemplo de una función, considera encontrar el effi-
ciency factores para un diseño de bloque. (Un poco aspectos de este problema ya ha sido
hablado en Sección 5.3 [matrices de Índice], página 19.)
Un diseño de bloque está definido por dos factores, decir bloques (b niveles) y variedades
(v niveles). Si R y K es el v por v y b por b replicaciones y medida de bloque matrices,
respectivamente, y N es el b por v matriz de incidencia, entonces los factores de eficacia
están definidos como el eigenvalues de la matriz
E = Yov − R −1/ 2NT K −1NR −1 / 2 = yov − Un T Un,
Dónde Un = K−1/2NR−1/2. Una manera para escribir la función está dada abajo.
> bdeff <- Función(bloques, variedades) {
Bloques <- cuando.Factor(bloques) # movimiento de seguridad menor
b <- Longitud(niveles(bloques))
Variedades <- cuando.Factor(variedades) # movimiento de seguridad menor
v <- Longitud(niveles(variedades))
K <- Cuando.Vector(mesa(bloques)) # saca dim attr
R <- Cuando.Vector(mesa(variedades)) # saca dim attr
funciones propias
N <- Mesa(bloques, variedades)

Un <- 1/sqrt(K) * N * rep(1/sqrt(R), rep(b,
v)) sv <- svd(Un)
Lista(eff=1 - sv$d^2, blockcv=sv$u, varietycv=sv$v)
}
Es numéricamente ligeramente mejor de trabajar con la descomposición de valor
singular en esta ocasión más que el eigenvalue rutinas.
El resultado de la función es una lista dando no sólo los factores de eficacia como el
primer componente, pero también el bloque y variedad contrastes canónicos, desde
entonces a veces estos dan adicionales información cualitativa útil.
10.6.2 Cayendo todos los nombres en una variedad imprimida
Para imprimir propósitos con variedades o matrices grandes, es a menudo útil de imprimirles
en forma de bloque cercano sin los nombres de variedad o números. Sacando el dimnames
el atributo no conseguirá este efecto, sino la variedad tiene que ser dada un dimnames el
atributo que consta de cuerdas vacías. Por ejemplo para imprimir una matriz, X
> temp <- X
> dimnames(temp) <- Lista(rep("", nrow(X)), rep("", ncol(X)))
> temp; rm(temp)
Esto puede ser mucho más oportunamente hecho utilizando una función, no.dimnames(),
mostrado abajo, como “envolver alrededor” para conseguir el mismo resultado. También ilustra
qué algunos usuario eficaz y útil las funciones pueden ser bastante cortas.
No.dimnames <- Función(un) {
## Sacar todos nombres de dimensión de una variedad para impresión compacta.
d <-
Lista() l
<- 0
Para(i en dim(un)) {
d[[l <- l + 1]] <- rep("", i)
}
dimnames(Un) <-
d un
}
Con esta función definió, una variedad puede ser imprimida en el formato cercano que utiliza
> No.dimnames(X)
Esto es particularmente útil para variedades de entero grande, donde los patrones son
el interés real más que los valores.
10.6.3 Recursive Integración numérica
Las funciones pueden ser recursivas, y los poder define funciones dentro ellos. Nota, aun así,
que tales funciones, o de hecho variables, no es heredado por llamó funciones en marcos de
evaluación más alta cuando serían si eran en el camino de búsqueda.
El ejemplo bajo espectáculos un naive manera de actuar integración numérica
unidimensional. El integrand está evaluado al final puntos de la gama y en el medio. Si el-
tablero trapezium respuesta de regla es bastante cercana al dos tablero, entonces el último
está regresado como el valor. Otherwise El mismo proceso es recursively aplicado a cada
tablero. El resultado es un adaptive la integración procesa aquello concentra evaluaciones de
función en regiones donde el integrand es más lejano de lineal. hay, aun así, un pesado
elevado, y la función es sólo competitiva con otros algoritmos cuándo el integrand es
ambos liso y muy difícil de evaluar..
El ejemplo es también dado en parte como rompecabezas pequeño en R programación.
Área <- función(f, un, b, eps = 1.0e-06, lim = 10) {
funciones propias
Divertido1 <- función(f, un, b, fa, fb, un0, eps,

lim, diversión) { ## diversión ‘de función1' es sólo área de
interior ‘visible'
d <- (Un +
b)/2 h <- (b
- un)/4
fd <- f(d)
Un1 <- h * (fa +
fd) un2 <- h * (fd
+ fb)
Si(abs(un0 - un1 - un2) < eps || lim
== 0) regreso(un1 + un2)
Más {
Regreso(diversión(f, un, d, fa, fd, un1, eps, lim -
1, diversión) + diversión(f, d, b, fd, fb,
un2, eps, lim - 1, diversión))
}
}
fa <- f(Un)
fb <- f(b)
Un0 <- ((fa + fb) * (b - un))/2
Divertido1(f, un, b, fa, fb, un0, eps, lim, diversión1)
}
10.7 Scope
La discusión en esta sección es un poco más technical que en otras partes de este
document. However, detalla uno de el m unjor diferencias between S-PLUS y R..
Los símbolos qué ocurrir en el cuerpo de una función puede ser dividido a tres clases;
parámetros formales, variables locales y variables libres. Los parámetros formales de una
función son aquellos ocurriendo en la lista de argumento de la función. Sus valores están
determinados por el proceso de obligatorio los argumentos de función reales 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. Variables qué no es los
parámetros formales o las variables locales se apellidan variables libres. Las variables libres
devienen variables locales si están asignados a. Considerar la definición de función
siguiente.
f <- Función(x) {
y <- 2*x
impresión(x)
impresión(y)
impresión(z)
}
En esta función, x es un parámetro formal, y es una variable local y z es una variable libre.
En R las encuadernaciones variables libres están resueltas por primero mirando en el
entorno en qué la función estuvo creado. Esto se apellida alcance léxico. Primero definimos
una función cubo llamado.
Cubo <- función(n) {
sq <- función() n*n
n*sq()
}
El variable n en el f unction sq no es un argument a aquella función. Therefore Es
un libre variable y el scoping rules must be utilizó para constatar tél value then es a be
asnoociated con él. Bajo estático scope (S-PLUS) el value es que asnoociated con un
global variable nombró n. Bajo léxico scope (R) es t he parámetro a el cubo de función
desde aquel es el active atando para el variable n en el tiempo t funcione sq wcuando
funcionesLa
definió. propias
diferencia between evaluatión en R y e valuation en S-EL PLUS es que S-
PLUS looks para un global variable llamó n mientras R primer looks para un variable
llamó n en el e nvironment creó cuándo cubo wcuando i nvoked.
funciones propias
## Primera evaluación en S
S> Cubo(2)
Error en sq(): Objeto "n" no fundar
Vertido
S> n <- 3
S> Cubo(2)
[1] 18
## Entonces la misma función evaluada en R
R> Cubo(2)
[1] 8
El alcance léxico también puede soler dar funciones mutable estado. En el ejemplo
siguiente muestramos qué R puede soler mimic una cuenta de banco. Unas necesidades
de cuenta de banco de funcionamiento para tener un equilibrio o total, una función para
hacer retiradas, una función para hacer depósitos y una función para declarar el equilibrio
actual. Conseguimos esto por crear las tres funciones dentro cuenta y entonces
regresando una lista que les contiene . Cuándo la cuenta está invocada él toma un total
de argumento numérico y regresa una lista que contiene las tres funciones. Porque estas
funciones están definidas en un entorno qué contiene total, tendrán acceso a su valor.
El operador de asignación especial, <<-, suele cambio el valor asociado con total . Estas
miradas de operador atrás en encerrar entornos para un entorno que contiene el total de
símbolo y cuándo encuentra tal un entorno reemplaza el valor, en aquel entorno, con el
valor de lado de mano correcta. Si el global o entorno de nivel superior está logrado sin
encontrar el total de símbolo entonces que variable está creado y asignado a allí. Para
más usuarios <<- crea una variable global y asigna el valor del lado de mano correcto a él 2.
Sólo cuando <<- ha sido utilizado en una función que estuvo regresado como el valor de
otra función el comportamiento especial describió aquí ocurrir.
Abierto.Cuenta <- función(total)
{ lista(
Función = de
depósito(cantidad) {
si(cantidad <= 0)
Parón("los depósitos tienen que ser
positivos!\n") Total <<- cantidad +
total
Gato(cantidad, "depositó. Vuestro equilibrio es", total, "\n\n")
},
Retira = función(cantidad) {
si(total > de cantidad)
Parón("no tienes que mucho dinero!\n")
Total <<- total - cantidad
Gato(cantidad, "retirado. Vuestro equilibrio es", total, "\n\n")
},
Función = de equilibrio() {
Gato("Vuestro equilibrio es", total, "\n\n")
}
)
}
ross <-
Abierto.Cuenta(100)
robert <-
abierto.Cuenta(200)
ross$Retirar(30)
2
En algunos notan esto mimics el comportamiento en S-PLUS desde entonces en S-MÁS este operador
siempre crea o asigna a una variable global.
funciones propias
ross$Equilibrio()
robert$equilibrio()
ross$Depósito(50)
ross$equilibrio()
ross$retirar(500)
10.8 Personalizando el entorno

Los usuarios pueden personalizar su entorno en varias maneras diferentes. Hay un
archivo de inicialización del sitio y cada directorio puede tener su archivo de
inicialización especial propio. Finalmente, las funciones especiales
.Primero y .Último puede ser utilizado.
La ubicación del archivo de inicialización del sitio está tomada del valor del R_variable
de entorno del PERFIL. Si aquella variable es unset, el archivo Rprofile.Sitio en el R
subdirectorio de casa etc está utilizado. Este archivo tendría que contener las órdenes que te
quiere ejecutar cada vez R está empezado bajo vuestro sistema. Un segundo, personal,
archivo de perfil nombró .Rprofile3 puede ser colocado en cualquier directorio. Si R está
invocado en aquel directorio entonces que el archivo será sourced. Este archivo da control de
usuarios individuales sobre su workspace y deja para diferente startup procedimientos en
directorios laborables diferentes. Si no .Rprofile El archivo está encontrado en el startup
directorio, entonces R busca un .Rprofile Archivo en el directorio de casa del usuario y
utiliza que (si existe). Si el entorno variable R_USUARIO_de PERFIL está puesto, el archivo
señala a está utilizado en vez de el .Rprofile Archivos.
Cualquier función nombró .Primero() en cualquier de los dos archivos de perfil o en el
.RData La imagen tiene un estado especial. Es automáticamente actuado a principios de
un R sesión y puede soler inicializar el entorno. Por ejemplo, la definición en el ejemplo
abajo altera el puntual a $ e instala varias otras cosas útiles que entonces puede ser dado
por hecho en el resto de la sesión.
Así, la secuencia en qué archivos está ejecutada es, Rprofile.Sitio, el perfil de usuario, .RData
Y entonces .Primero(). Una definición en archivos más tardíos enmascarará definiciones en archivos
más tempranos.
> .Primer <- función() {
Opciones(puntuales="$ ", continúa="+\t") # $ es las opciones
puntuales(dígitos=5, longitud=999) # números hechos de encargo
y printout x11() # para gráficos
par(pch = "+") # plotting Carácter
Fuente(archivo.Camino(Sys.getenv("CASA"), "R", "mystuff.R"))
# Mis funciones personales
Biblioteca(MASA) # sujeta un paquete
}
De modo parecido una función .Dura(), si definido, es (normalmente) ejecutó en el muy fin de la
sesión.
Un ejemplo está dado abajo.
> .Último <- función() {
Gráfico.Fuera() # una medida de seguridad pequeña.
Gato(pasta(fecha(),"\nAdios\n")) # Es cronometra para comida?
}
10.9 ClAsnos, objeto y funciones genéricos orientación

La clase de un objeto determina cómo sea tratado por qué es sabido como funciones
genéricas. Puesto al revés, una función genérica actúa una tarea o acción en sus argumentos
concretos a la clase del argumento él. Si el argumento carece de cualquier atributo de
clase, o tiene una clase
3
Así que está escondido debajo UNIX.
funciones propias
No proveído para específicamente por la función genérica en cuestión, hay siempre un default acción
Proporcionado.
Unas cosas de marcas del ejemplo más claras. El mecanismo de clase ofrece el usuario la
facilidad de diseñar y escribiendo funciones genéricas para propósitos especiales. Entre las otras
funciones genéricas son parcela () para mostrar objetos graphically, resumen() para
summarizing análisis de varios tipos, y anova() para comparar modelos estadísticos.
El número de funciones genéricas que puede tratar una clase en una manera concreta
puede ser bastante grande. Por ejemplo, las funciones que puede acomodar en algunos
objetos de moda de dato "de clase.El marco" incluye
[ [[<- Cualq Cuando.Ma
uiera tricial
[<- Malo Parce Resumen
la
Una lista actualmente completa puede ser conseguida por utilizar los métodos() función:
> Métodos(dato="de clase.Marco")
En cambio el número de clases una función genérica puede manejar también puede ser
bastante grande. Por ejemplo la parcela() la función tiene un default método y variantes para
objetos de dato "de clases.Marco", "densidad", "factor", y más. Una lista completa
puede ser conseguida otra vez por utilizar los métodos() función:
> Métodos(parcela)
Para muchos funciones genéricas el cuerpo de función es bastante corto, por ejemplo.
> coef
Función (objeto, ...)
UseMethod("coef")
La presencia de UseMethod indica esto es una función genérica . Para ver lo que los métodos
son disponibles podemos utilizar métodos()
> Métodos(coef)
[1] coef.aov* coef.Arima* coef.default* coef.listof*
[5] coef.nls* coef.Resumen.nls*
Funciones no visibles son asterisked

En este ejemplo allí es seis métodos, ninguno de los cuales pueden ser vistos por escribir
su nombre. Podemos leer estos por cualquier de
> getAnywhere("coef.aov")
Un objeto solo que empareja 'coef.aov'
Estuvo encontrado Lo estuvo encontrado en
los sitios siguientes
Registrado S3 método para coef de namespace stats
namespace:stats
Con valor
Función (objeto, ...)

{
z <-
Objetar$coef
z[!is.na(z)]
}
> Consigue3método("coef",
"aov") función (objeto,
...)
{
z <-
Objetar$coef
z[!is.na(z)]
50
}
Una función nombró gen.cl Será invocado por el genérico gen para clase cl, así que no
nombra funciones en este estilo a no ser que están pretendidos para ser métodos.
El lector está referido al R Definición de Lengua para una discusión más completa de este
mecanismo.
51
11 Statistical Modelos en R
Esta sección presumes el lector tiene alguna familiaridad con metodología estadística, en
particular con análisis de regresión y el análisis de varianza. Más tarde hacemos algunos
bastante presunciones más ambiciosas, concretamente que algo es sabido
aproximadamente modelos lineales generalizados y nonlinear regresión.
Los requisitos para caber los modelos estadísticos son suficientemente bien definidos
para hacerlo posible para construir herramientas generales que aplica en un espectro
ancho de problemas..
R Proporciona un interlocking suite de instalaciones que la marca que cabe modelos
estadísticos muy sencillos. Cuando mencionamos en la introducción, la producción
básica es mínima, y uno necesita pedir los detalles por llamar extractor funciones.
11.1 Definiendo modelos estadísticos; formulae

La plantilla para un modelo estadístico es un modelo de regresión lineal con
independiente, homoscedastic errores
p
Σ
yi = βjx ij + ei, ei ∼ NID(0, σ 2), i = 1, . . . , n
j=0
En matricial denomina esto sería escrito
y = Xβ + e
Dónde el y es el vector de respuesta, X es la matriz de modelo o matriz de diseño y tiene
columnas x0, x1, . . . , xp , las variables de determinar. Muy a menudo x0 será una columna de
unos definiendo un interceptar plazo.
Ejemplos
Antes de dar una especificación formal, unos cuantos ejemplos pueden útilmente puestos el cuadro.
Supone y, x, x0, x1, x2, . . . Es variables numéricas, X es un matricial y Un , B, C, . . . Es
factores. El siguiente formulae en el lado izquierdo abajo especifica modelos estadísticos
cuando descritos en el correctos.
y~x
y~1+x Tanto implicar el mismo modelo de regresión lineal sencillo de y en x. El
primero tiene un implícito intercepta plazo, y el segundo un explícito un.
y~0+x
~ y -1 +
x
y~x-1 regresión lineal Sencilla de y en x a través del origen (aquello es, sin un
interceptar plazo).
Registro(y) ~ x1 + x2
Regresión múltiple de la variable transformada, registro(y), en x1 y x 2 (con
un implícito intercepta plazo).
y ~ poly(x,2)
y ~ 1 + x + yo(x^2)
Regresión polinómica de y en x de grado 2. La primera forma utiliza ortogonal
polyno- mials, y los segundos usos poderes explícitos, cuando base.
y ~ X + poly(x,2)
Regresión múltiple y con matriz de modelo que consta de la matriz X así
como plazos polinómicos en x a grado 2.
Capítulo 11: modelos 52
Estadísticos en R
y ~ Un análisis de clasificación Solo de modelo de varianza de y , con las clases determinaron por Un .
y ~ Un + x análisis de clasificación Sola de modelo de covarianza de y , con las clases determinaron por
Un, y con covariate x.
y ~ Un*B
y ~ Un + B + Un:B
y ~ B En Un
y ~ Un/B Dos factor modelo no aditivo de y en Un y B . El primeros dos especifican
clasificación cruzada igual y el segundos dos especifican el mismo nested
clasificación. En abstracto denomina todo cuatro especifica el mismo modelo
subspace.
y ~ (Un + B + C)^2
y ~ Un*B*C - Un:B:C
Tres experimento de factor pero con un modelo que contiene efectos
principales y dos interacciones de factor sólo. Ambos formulae especificar el
mismo modelo.
y ~ Un *
x ~y
Un/x
y ~ Un/(1 + x) - 1
Modelos de regresión lineales sencillos separados de y en x dentro de los niveles
de Un , con codificaciones diferentes. La última forma produce estimaciones
explícitas de tan muchos diferentes intercepta y pendientes tan hay niveles en Un
.
y ~ Un*B + Error(C)
Un experimento con dos factores de tratamiento, Un y B , y estratos de error
determinaron por factor C. Por ejemplo un experimento de parcela de la
ruptura, con parcelas enteras (y de ahí también subplots), determinados por
factor C.
El operador ~ suele definir una fórmula de modelo en R. La forma, para un modelo
lineal normal, es
Respuesta ~ op_1 plazo_1 op_2 plazo_2 op_3 plazo_3 ...
Dónde
La respuesta es un vector o matriz, (o la expresión que evalúa a un vector o matricial)
definiendo la variable de respuesta(s).
op i Es un operador, cualquiera + o - , implicando la inclusión o exclusión de un
plazo en el modelo, (el primero es opcional).
Plazo i es tampoco
• Un vector o expresión matricial, o 1 ,
• Un factor, o
• Una expresión de fórmula que consta de factores, los vectores o las matrices conectaron
por
Operadores de fórmula.
En todos los casos cada plazo define una colección de columnas tampoco para
ser añadidos a o sacados de la matriz de modelo. Unas 1 posiciones para un
interceptar columna y es por default incluido en la matriz de modelo a no ser
que explícitamente sacó.
Los operadores de fórmula son similares en efecto al Wilkinson y Rogers la notación
utilizada por such programas como Glim y Genstat. Uno inevitable change es que el
operator ‘.' becomes ‘:' Desde el periodo es un carácter de nombre válido en R.
La notación es summarized abajo (basado en Cuartos & Hastie, 1992, p.29):
Y ~ M Y es modeled cuando M .
M_1 + M_2 Incluye M 1 y M 2.
Estadísticos en R
M_1 - M_2 Incluye M 1 dejando fuera de plazos de M 2.

M_1 : M_2 El producto de tensor de M 1 y M 2. Si ambos plazos son factores , entonces el
“factor” de subclases.
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 plazos en M junto con “interacciones” hasta orden n
Yo(M) Insulate M. Interior M todos los operadores tienen su significado de aritmética
normal, y que el plazo aparece en la matriz de modelo.
Nota que dentro de los paréntesis que normalmente encerrar argumentos de función
todos los operadores tienen su significado de aritmética normal. La función yo() es una
función de identidad utilizó para dejar plazos en modelo formulae para ser definido
utilizando operadores de aritmética.
Nota particularmente que el modelo formulae especificar las columnas de la matriz
de modelo, la especificación de los parámetros que son implícitos. Esto no es el caso en
otros contextos, por ejemplo en especificar nonlinear modelos.
11.1.1 Contrastes
Necesitamos al menos alguna idea cómo el modelo formulae especificar las columnas de
la matriz de modelo. Esto es fácil si tenemos variables continuas, cuando cada cual
proporciona una columna de la matriz de modelo (y el intercepta proporcionará una
columna de unos si incluidos en el modelo).
Qué sobre un k-factor de nivel Un? La respuesta difiere para unordered y ordenó factores.
Para unordered factores
− k 1 columnas están generadas para los indicadores del segundo, . .
. , kth niveles del factor. (Por ello el implícito parameterization es para contrastar la
respuesta en cada nivel con aquel en el primero.) Para ordenó factores el k 1 columnas
son los polinomios ortogonales encima 1, .− . . , k, omitiendo el plazo constante.
A pesar de que la respuesta es ya complicada, no es la historia entera. Primero, si el
interceptar está omitido en un modelo que contiene un plazo de factor, el primer tal plazo
está codificado a k las columnas que dan los indicadores para todos los niveles. Segundo, el
comportamiento entero puede ser cambiado por las opciones que ponen para
contrastes. El default encuadre en R es
Opciones(contrastes = c("contr.Tratamiento", "contr.poly"))
La razón principal para mí ntioning esto es que R y S hunve different defaults para
unordered factores, S utilizando Helmert contrasts. Tan si y ou necesidad de comparar
ynuestros resultados a aquellos de un textobovale o pa per which utilizó S-PLUS, you
necesitará poner
Opciones(contrastes = c("contr.helmert", "contr.poly"))
Esto es una diferencia deliberada , cuando contrastes de tratamiento (R default) está
pensado más fácil para nuevo- comers para interpretar.
Todavía hemos acabado no, cuando el esquema de contraste para ser utilizado puede
ser puesto para cada plazo en el modelo que utiliza los contrastes de funciones y C .
No hemos considerado todavía plazos de interacción: estos generan los productos de
las columnas introdujeron para sus plazos de componente.
A pesar de que los detalles están complicados, modelo formulae en R normalmente
generará los modelos que un estadístico experto esperaría, proporcionado que marginality
está preservado. Cabiendo, por ejemplo, un modelo con una interacción pero no los efectos
principales correspondientes en general dirigirán a resultados sorprendentes, y es para
expertos sólo.
Estadísticos en R
11.2 Linear modelos

La función básica para caber los modelos múltiples normales es lm(), y un streamlined la
versión de la llamada es como sigue:.
> Cabido.Modelo <- lm(fórmula, dato = de dato.Marco)
Por ejemplo
> fm2 <- lm(y ~ x1 + x2, producción = de dato)
Cabría un modelo de regresión múltiple de y en x1 y x 2 (con implícito intercepta plazo).
El importante (pero técnicamente opcional) producción de dato = del parámetro
especifica que cualesquier variables necesitaron construir el modelo tendría que venir primero
del marco de dato de la producción. Esto es el caso a toda costa de si producción de
marco del dato ha sido sujetada en el camino de búsqueda o no .
11.3 Funciones genéricas para extraer información de modelo

El valor de lm() es un objeto de modelo cabido; técnicamente una lista de resultados de clase
"lm". Información sobre el modelo cabido entonces puede ser mostrado, extraído, plotted y
tan encima por utilizar funciones genéricas que los orienta a objetos de clase "lm". Estos
incluyen
Añade deviance Fórmula Pronosti Paso
1 ca
Alias Gota1 kappa Impresió Resumen
n
anova Efectos Etiquetas proj vcov
coef Familiar Parcela residuals
Una descripción breve del más generalmente utilizó unos está dado abajo.
anova(Objeto_1, objeto_2)
Comparar un submodel con un modelo exterior y producir un análisis de mesa de varianza.
coef(Objeto)
Extracto el coeficiente de regresión
(matricial). Forma larga:
coeficientes(objeto).
deviance(Objeto)
Suma residual de plazas, weighted si apropiados.
Fórmula(objeto)
Extracto la fórmula de modelo.
Parcela(objeto)
Producto cuatro parcelas, mostrando residuals, cupo valores y algunos diagnósticos.
Pronostica(objeto, newdata=dato.Marco)
El marco de dato suministró tiene que tener las variables especificaron con las
mismas etiquetas como el original. El valor es un vector o matriz de
pronosticado valora corresponder al determinando valores variables en
datos.Marco.
Impresión(objeto)
Impresión una versión concisa del objeto. Más a menudo utilizado implícitamente.
residuals(Objeto)
Extracto el (matriz de) residuals, weighted como
apropiado. Forma corta: resid(objeto).
Paso(objeto)
Seleccionar un modelo adecuado por añadir o cayendo plazos y preservando
jerarquías. El modelo con el valor más pequeño de AIC (Akaike es Un Criterio
de Información) descubrió en el stepwise la búsqueda está regresada.
Estadísticos en R
Resumen(objeto)
Impresión un resumen comprensible de los resultados del análisis de regresión.
vcov(Objeto)
Regresos la varianza-matriz de covarianza de los parámetros principales de un
objeto de modelo cabido.
11.4 Unnalysis de varianza y comparación de modelo

El modelo que cabe función aov(fórmula, dato=de dato.Marco) opera en el nivel más
sencillo en una manera muy similar a la función lm(), y la mayoría de las funciones genéricas
listó en la mesa en Sección 11.3 [funciones Genéricas para extraer información de modelo],
página 54, aplica.
Tenga que ser notado que además aov() deja un análisis de modelos con estratos de
error múltiple como experimentos de parcela partida, o diseños de bloque incompletos
equilibrados con recuperación de inter-información de bloque. La fórmula de modelo
La respuesta ~ mala.Error + de fórmula(estratos.Fórmula)
Especifica un multi-experimento de estrato con estratos de error definió por los
estratos.Fórmula. En el caso más sencillo, estratos.La fórmula es sencillamente un factor,
cuándo define un dos experimento de estratos, concretamente entre y dentro de los niveles
del factor.
Por ejemplo, con todo determinando factores de variables, una fórmula de modelo como aquel en:
> fm <- aov(Cosecha ~ v + n*p*k + Error(bloques/de granjas), granja=de dato.Dato)
Típicamente soler describir un experimento con modelo malo v + n*p*k y tres estratos de
error, concretamente “entre granjas”, “dentro de granjas, entre bloques” y “dentro de
bloques”.
11.4.1 ANOVA mesas

Nota también que el análisis de mesa de varianza (o mesas) es para una secuencia de cupo
modelos. Las sumas de las plazas mostradas es la disminución en las sumas residuales de
las plazas que resultan de una inclusión de aquel plazo en el modelo en aquel sitio en la
secuencia. De ahí sólo para experimentos ortogonales el orden de inclusión ser
intrascendente.
Para multistratum experimentos el procedimiento es primero para proyectar la
respuesta a los estratos de error, otra vez en secuencia, y para caber el modelo malo a
cada proyección. Para detalles más lejanos, ver Cuartos & Hastie (1992).
Una alternativa más flexible al default lleno ANOVA la mesa es para comparar dos o más
modelos directamente utilizando el anova() función.
> anova(Cabido.Modelo.1, cupo.Modelo.2, ...)
La exhibición es entonces un ANOVA la mesa que muestra las diferencias entre el
cupo los modelos cuándo cabidos en secuencia. El cupo modelos siendo comparados
normalmente sería una secuencia jerárquica, naturalmente. Esto no da información
diferente al default, sino lo hace más fácil a comprehend y control..
11.5 Updating Cupo modelos

La actualización() la función es en gran parte una comodidad funciona aquello deja un modelo
para ser cabido aquello difiere de uno anteriormente cabido normalmente por justo unos cuantos
adicional o sacó plazos. Su forma es
> Nuevo.Modelo <- actualización(viejo.Modelo, nuevo.Fórmula)
En th e nuevo.Formaula el special el nombre que consta de un p eriod, ‘.', sólo, puede be
utilizado para estar para “la parte correspondiente de la fórmula de modelo vieja”. Por
ejemplo,
> fm05 <- lm(y ~ x1 + x2 + x3 + x4 + x5, producción = de dato)
> fm6 <- actualización(fm05, . ~ . + x6)
> smf6 <- actualización(fm6, sqrt(.) ~ .)
Estadísticos en R
Cabría un cinco variate regresión múltiple con variables (presumiblemente) de la producción

de marco del dato, cabido un modelo adicional que incluye un sexto regressor variable, y
caber una variante en el modelo donde la respuesta tuvo una raíz cuadrada transforma
aplicada.
Nota especialmente que si el argumento= de dato está especificado en la llamada
original al modelo que cabe función, esta información está pasada encima a través del
objeto de modelo cabido para actualizar() y sus aliados.
El nombre ‘.' Puede unl so be utilizó en otro contextos, pero con slig htly different
significado. FO ejemplo.
> fmfull <- lm(y ~ . , producción = de dato)
Cabría un modelo con respuesta y y regressor variables todas otras variables en el marco de dato
Producción.
Otras funciones para explorar las secuencias incrementales de modelos son añade1(),
gota1() y paso() . Los nombres de estos dar una pista buena a su propósito, pero para los
detalles llenos ven la ayuda on-line.
11.6 Modelos lineales generalizados

El Modeling lineal generalizado es un desarrollo de modelos lineales para acomodar
ambas respuesta no normal distribuciones y transformaciones a linealidad en una manera
limpia y sincera. Un modelo lineal generalizado puede ser descrito en plazos de la
secuencia siguiente de suposiciones:.
• Hay una respuesta, y, de interés y variables de estímulo x1, x2, . . . , cuyos valores
influyen la distribución de la respuesta.
• Las variables de estímulo influyen la distribución de y a través de una función lineal sola, sólo.
Esta función lineal se apellida el lineal predictor, y es normalmente escrito
η = β1x1 + β2x2 + · · · + βpxp ,
Por ello x i tiene ninguna influencia en la distribución de y si y sólo si βi = 0.

• La distribución de y es de la forma
Σ Σ
Un
f (y; Yµ, ϕ) = exp {yλ(µ) − γ (λ(µ))} + τ (y, ϕ)
ϕ
Dónde ϕ es un parámetro de escala (posiblemente sabido), y es constante para todas las

observaciones, Un
Representa un peso previo, supuesto sabido pero posiblemente variando con las observaciones, y
µ Es el malo de y . Así que está supuesto que la distribución de y está determinado
por su malo y posiblemente un parámetro de escala también.
• El malo, µ, es una función invertible lisa del lineal predictor:
µ = m(η), η = m−1(µ) =
Un(µ) y este inverse función, Un(), se apellida la función
de enlace.
Estas suposiciones son bastante sueltas para abarcar una clase ancha de los modelos
útiles en práctica estadística, pero bastante estanco para dejar el desarrollo de una
metodología unificada de valoración e inferencia, al menos aproximadamente. El lector
está referido a cualquiera de los trabajos de referencia actuales en el tema para detalles
llenos, como McCullagh & Nelder (1989) o Dobson (1990).
Estadísticos en R
11.6.1 Families
La clase de modelos lineales generalizados manejó por las instalaciones suministraron en R
incluye gaussiano, binomio, poisson, inverse gaussiano y gamma distribuciones de respuesta
y también quasi-likelihood modelos donde la distribución de respuesta no es explícitamente
especificó. En el caso último la función de varianza tiene que ser especificada como función
del malo, pero en otros casos esta función está implicada por la distribución de respuesta.
Cada distribución de respuesta admite una variedad de funciones de enlace para
conectar el malo con el lineal predictor. Aquellos automáticamente disponibles está
mostrado en la mesa siguiente:
Funciones de Enlace de nombre familiares

Binomial logit, probit, registro, cloglog
Identidad gaussiana, registro, inverse
Gamma Identidad , inverse, registro
inverse.Gaussiano 1/mu^2, identidad, inverse,
registro poisson identidad, registro, sqrt
quasi logit, probit, cloglog, identidad, inverse,
registro, 1/mu^2, sqrt
La combinación de una distribución de respuesta, una función de enlace y varias otras
piezas de infor- mation aquello está necesitado para llevar a cabo el ejercicio de modeling se
apellida la familia del modelo lineal generalizado.
11.6.2 El glm() función

Desde la distribución de la respuesta depende de las variables de estímulo a través de una
función lineal sola sólo, el mismo mecanismo cuando estuvo utilizado para los modelos
lineales todavía pueden soler especificar la parte lineal de un modelo generalizado. La
familia tiene que ser especificada en una manera diferente.
El R función para caber un modelo lineal generalizado es glm() cuál utiliza la forma
> Cabido.Modelo <- glm(fórmula, familia=familiar.Generador, dato=de dato.Marco)
La característica nueva única es la familia .Generador, el cual es el instrumento por
qué la familia está descrita. Es el nombre de una función que genera una lista de
funciones y expresiones que juntos definir y controlar el modelo y proceso de valoración.
A pesar de que esto puede parecer un poco complicado a primera vista, su uso es bastante
sencillo.
Los nombres del estándar, los generadores familiares suministrados están dados bajo
“Nombre Familiar” en la mesa en Sección 11.6.1 [Familias], página 57. Dónde hay una
elección de enlaces, el nombre del enlace también puede ser suministrado con el nombre
familiar, en paréntesis como parámetro. En el caso de el quasi familia, la función de
varianza también puede ser especificada de este modo..
Algunos ejemplos hacen el proceso claro.
La familia gaussiana
Una llamada como
> fm <- glm(y ~ x1 + x2, familiar = gaussiano, ventas = de dato)
Consigue el mismo resultado cuando
> fm <- lm(y ~ x1+x2, ventas=de dato)
Pero mucho menos efficiently. Nota cómo la familia gaussiana no es automáticamente
proporcionado con una elección de enlaces, así que ningún parámetro está dejado. Si un
problema requiere una familia gaussiana con un nonstandard enlace, esto normalmente puede
ser conseguido a través del quasi familia, cuando veremos más tarde.
La familia binomial
Considerar un ejemplo pequeño, artificial, de Silvey (1970).
Estadísticos en R
En el Aegean isla de Kalythos los habitantes machos adolecen una enfermedad de ojo
congénita, los efectos del cual deviene más marcado con edad creciente. Muestras de
islander los machos de varias edades estuvieron probados para la ceguera y los resultados
grabaron. El dato está mostrado abajo:
Edad: 20 35 45 55 70
El núm. 50 50 50 50 50
probó:
El núm. 6 17 26 37 44
ciego:
El problema consideramos es para caber ambos logistic y probit modelos a este dato,
y para estimar para cada modelo el LD50, aquello es la edad en qué la posibilidad de la
ceguera para una habitante macho es 50%.
Si y es el número de ciego en edad x y n el número probó, ambos modelos tienen la forma
y ∼ B(n, F (β0 + β1x))
Dónde para el probit caso, F (z) = Φ(z) es la función de distribución normal estándar, y
en el logit caso (el default), F (z) = ez/(1 + ez). En ambos casos el LD50 es
LD50 = −β0/β1
Aquello es, el punto en qué el argumento de la función de distribución es cero.

El primer paso es para poner el dato arriba como marco de datos
> kalythos <- Datos.Marco(x = c(20,35,45,55,70), n = rep(50,5),
y = c(6,17,26,37,44))
Para caber un modelo binomial que utiliza glm() hay tres posibilidades para la respuesta:
• Si la respuesta es un vector está supuesto para aguantar dato binario, y así que tiene
que ser un 0/1 vector. Si la respuesta es una matriz de dos columnas está supuesto
•
que la primera columna aguanta el número de éxitos para la prueba y los segundos
controles el número de fracasos..
• Si la respuesta es un factor , su primer nivel está tomado tan fracaso (0) y todos otros
niveles cuando ‘éxito' (1).
Aquí necesitamos el segundo de estas convenciones, así que añadimos un matriciales a nuestro
marco de dato:
> kalythos$Ymat <- cbind(kalythos$y, kalythos$n - kalythos$y)
Para caber los modelos utilizamos
> fmp <- glm(Ymat ~ x, binomio = familiar(enlace=probit), dato = kalythos)
> fml <- glm(Ymat ~ x, binomio = familiar, dato = kalythos)
Desde el logit el enlace es el default el parámetro puede ser omitido en la segunda
llamada. Para ver los resultados de cada cabidos podríamos utilizar
> Resumen(fmp)
> Resumen(fml)
Ambas acceso de modelos (todo también) bien. Para encontrar la LD50 estimación podemos
utilizar una función sencilla:
> ld50 <- función(b) -b[1]/b[2]
> ldp <- ld50(coef(fmp)); ldl <- ld50(coef(fml)); c(ldp, ldl)
Las estimaciones reales de este dato son 43.663 años y 43.601 años respectivamente.
Poisson Modelos
Con el Poisson familia el default el enlace es el registro , y en practicar el uso
importante de esta familia es para caber surrogate Poisson registro-modelos lineales a dato
de frecuencia, cuya distribución real es a menudo multinomial. Esto es un tema grande e
importante no hablaremos más allá aquí. Incluso forma una parte importante del uso de
no-gaussiano generalizó modelos en general.
Estadísticos en R
Ocasionalmente sinceramente Poisson el dato surge en práctica y antiguamente sea a

menudo analizado como dato gaussiano después de cualquier un registro o una
transformación de raíz cuadrada. Como graceful alternativa al último, un Poisson
generalizó el modelo lineal puede ser cabido tan en el ejemplo siguiente:
> fmod <- glm(y ~ Un + B + x, familia =
poisson(enlace=sqrt), gusano = de
dato.Cuentas)
Quasi-likelihood Modelos
Para todas las familias la varianza de la respuesta dependerá de el malo y tendrá el
parámetro de escala como multiplier. La forma de dependencia de la varianza en el
malo es una característica de la distribución de respuesta; por ejemplo para el poisson
distribución Var[y] = µ.
Para quasi-likelihood valoración e inferencia la distribución de respuesta precisa no es
especificada, sino sólo una función de enlace y la forma de la función de varianza cuando
depende de el malo. Desde quasi-likelihood usos de valoración formalmente técnicas
idénticas a aquellos para la distribución gaussiana, esta familia proporciona una manera de
caber modelos gaussianos con enlace no estándar funciones o funciones de varianza,
adicionalmente.
Por ejemplo, considera caber la regresión no lineal
θ1z1
y= +e
z2 − θ2
Cuáles pueden ser escritos alternativamente cuando
1
y= +e
β1x1 + β2x2
Dónde x1 = z2/z1, x2 = − 1/z1, β1 = 1/θ1 y β 2 = θ2/θ1. Suponiendo un marco de dato
adecuado para ser instalado podríamos caber esto regresión no lineal cuando
> nlfit <- glm(y ~ x1 + x2 - 1,
Familiar = quasi(enlace=inverse, constante=de
varianza), dato = biochem)
El lector está referido al manual y el documento de ayuda para información más
lejana, cuando necesitó.
11.7 Nonlinear Menos plazas y máximos likelihood modelos

Formas seguras de n onlinear model puede be cabido by Generalizó Linear Models (glm()).
Pero en el m unjority de casos w e hunve a approa ch the nonlinear curve cabiendo
problema cuando uno de nonlinear optimización. R nonlinear rutinas de optimización
son optim(), nlm() y nlminb( ), which provide el functionality (y más) de S-Plus ms()
y nlminb() . We Busca el parámetro values aquello minimiza algún índice de la ck-of-fit,
y ellos este by probando fuera de v arious parámetro values iteratively. Unlike
Regresión lineal por ejemplo, hay no guarantee que el procedure converge en
estimaciones satisfactorias. Todo el methods requiere suposiciones iniciales unb fuera
de qué parámetro values a tr y, y co nvergence muny dep fin critically upen el quality de
el empezando values.
11.7.1 Least plazas

Una manera para caber un nonlinear el modelo es por minimizar la suma del cuadró
errores (SSE) o residuals. Este sentido de marcas del método si el observó los errores
podrían haber plausibly surgidos de una distribución normal.
Aquí es un ejemplo de Bates & Vatios (1988), página 51. El dato es:
> x <- c(0.02, 0.02, 0.06, 0.06, 0.11, 0.11, 0.22, 0.22, 0.56, 0.56,
Estadísticos en R
1.10, 1.10)
> y <- c(76, 47, 97, 107, 123, 139, 159, 152, 191, 201, 207, 200)
El criterio de acceso para ser minimizado es:
> fn <- Función(p) suma((y - (p[1] * x)/(p[2] + x))^2)
Para hacer el cabido necesitamos estimaciones iniciales de los parámetros. Una manera
para encontrar sensato empezando los valores es a parcela el dato, suposición algunos
valores de parámetro, y superponer la curva de modelo que utiliza aquellos valores.
> Parcela(x, y)
> xfit <- seq(.02, 1.1, .05)
> yfit <- 200 * xfit/(0.1 + xfit)
> Líneas(spline(xfit, yfit))
Podríamos hacer mejores, pero estos empezando valores de 200 y 0.1 parece adecuado. Ahora
hacer la acceso:
> Fuera <- nlm(fn, p = c(200, 0.1), hessian = CIERTO)
Después del cabiendo, fuera de$mínimo es el SSE, y fuera de$la estimación es el
menos cuadra estimaciones de los parámetros. Para obtener los errores estándares
aproximados (SE) de las estimaciones hacemos:
> sqrt(diag(2*fuera de$mínimo/(longitud(y) - 2) * soluciona(fuera de$hessian)))
El 2 cuál está restado en la línea encima representa el número de parámetros. Un 95%
intervalo de confianza sería la estimación de parámetro
± 1.96 SE. Podemos superponer el
menos cuadra cabido en una parcela nueva:
> Parcela(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 mucho más instalaciones extensas para caber
modelos no lineales por menos plazas. El modelo acabamos de caber es el Michaelis-
Menten modelo, así que podemos utilizar
> df <- Datos.Marco(x=x, y=y)
> Acceso <- nls(y ~ SSmicmen(x, Vm, K), df)
> Acceso
Nonlinear Modelo de modelo de
la regresión: y~
SSmicmen(x, Vm, K) dato:
df
Vm K
212.68370711 0.06412123
Suma residual-de-plazas: 1195.449
> Resumen(acceso)
Fórmula: y ~ SSmicmen(x, Vm, K)
Parámetros:
Estimación Std. Error t valor
Pr(>|t|) Vm 2.127e+02 6.947e+00
30.615 3.24e-11 K 6.412e-02 8.281e-03
7.743 1.57e-05
Error estándar residual: 10.93 encima 10 grados de
Correlación de libertad de Estimaciones de
Parámetro:
Vm
Estadísticos
K 0.7651en R
Estadísticos en R
11.7.2 Maximum likelihood

Máximo likelihood es un método de nonlinear el modelo que cabe que aplica incluso si los
errores no son normales. El método encuentra el parámetro valora cuál maximize el registro
likelihood, o equivalently cuáles minimizan el registro negativo-likelihood. Aquí es un
ejemplo de Dobson (1990), pp. 108–111. Este ejemplo cabe un logistic modelo a dosis-dato
de respuesta, el cual claramente también podría ser cabido por glm(). El dato es:
> 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)
El registro negativo-likelihood para minimizar es:
> fn <- Función(p)
Suma( - (y*(p[1]+p[2]*x) - n*registro(1+exp(p[1]+p[2]*x))
+ Registro(escoge(n, y)) ))
Elegimos sensatos empezando valores y hacer la acceso:
> Fuera <- nlm(fn, p = c(-50,20), hessian = CIERTO)
Después del cabiendo, fuera de$mínimo es el registro negativo-likelihood, y fuera de$la
estimación es el maxi- mamá likelihood estimaciones de los parámetros. Para obtener el
aproximado SEs de las estimaciones hacemos:
> sqrt(diag(Soluciona(fuera de$hessian)))
Un 95% intervalo de confianza sería la estimación de parámetro ± 1.96 SE.
11.8 Algunos modelos no estándares

Concluimos este capítulo con justo un breve mencionar de algunos de las otras instalaciones
disponibles en R para dato y regresión especiales problemas de análisis.
• Modelos mixtos. El recomendable nlme (https://cran.r-project.org/package=nlme)
el paquete proporciona funciones lme() y nlme() para lineales y no-modelos de efectos
mixtos lineales, aquello es lineal y regresiones no lineales en qué algún de los coeficientes
corresponden a efectos aleatorios. Estas funciones hacen uso pesado de formulae para
especificar los modelos.
• Local aproximando regresiones. El loess() la función cabe un nonparametric
regresión por utilizar un localmente weighted regresión. Tales regresiones son útiles para
destacar una tendencia en messy dato o para reducción de datos para dar alguna idea a
un conjunto de dato grande.
Función loess es en el paquete estándar stats, junto con código para regresión de
búsqueda de la proyección.
• Regresión robusta. Hay muchos funciona disponible para caber modelos de regresión en
una manera resistente a la influencia de extremo outliers en el dato. Función lqs en el
recom- mended MASA de paquete (https://cran.r-project.org/package=mass)
proporciona estatal- de-algoritmos de arte para acceso altamente resistentes. Menos resistente
pero statistically métodos más eficaces son disponibles en paquetes, por ejemplo funcionar
rlm en MASA de paquete (https:// CRAN.R-PROJECT.ORG/PACKAGE=MASS).
• Modelos aditivos. Estos objetivos de técnica para construir una función de regresión de liso
addi- tive funciones de las variables de determinar, normalmente uno para cada variable de
determinar. Func- tions avas Y as en paquete acepack (https://cran.r-
project.org/package=acepack) y funciones bruto y mars en paquete mda
(https: / / CRAN . R-Proyecto . org / Paquete=mda) proporciona algunos
ejemplos de estas técnicas en usuario-contribuyó paquetes a
R. Una extensión está Generalizada Modelos Aditivos , implementado en usuario-paquete
contribuido- edades gam (https: / / CRAN . R-Proyecto . org / Paquete=gam) y mgcv
(https: / / CRAN . R-project.org/package=mgcv).
Estadísticos en R
• Árbol-basó modelos. Más que buscar un modelo lineal global explícito para
predicción o interpretación, árbol-basó los modelos buscan a bifurcate el dato,
recursively, en puntos críticos de las variables de determinar para partición el dato
finalmente a grupos que es tan homogeneous tan posible dentro, y tan heterogéneo
como posible entre. Los resultados a menudo dirigen a ideas que otros métodos de
análisis del dato tienden no para ceder.
Los modelos son otra vez especificados en la forma de modelo lineal normal. El modelo
que cabe la función es árbol (), pero muchos otras funciones genéricas como
parcela() y texto() es bien adaptado a mostrar los resultados de un árbol-el modelo
basado cabido en una manera gráfica.
Modelos de árbol son disponibles en R vía el usuario-contribuyó paquetes rpart
(https: / / CRAN . R-Proyecto . org / Paquete=rpart) y árbol (https: / / CRAN . R-
Proyecto . org / Árbol=de paquete).
63
12 Graphical procedimientos
Las instalaciones gráficas son una componente importante y extremadamente versátil del
R entorno. Es posible de utilizar las instalaciones para mostrar una variedad ancha de
estadístico graphs y también para construir enteramente tipos nuevos de graph..
Las instalaciones de gráfico pueden ser utilizadas en ambos interactivos y modos de lote, pero
en más casos, el uso interactivo es más productivo. El uso interactivo es también fácil porque en
startup tiempo R inicia un conductor de dispositivo del gráfico qué abre una ventana de
gráfico especial para la exhibición de gráfico interactivo. A pesar de que esto está hecho
automáticamente, pueda útil de saber que la orden utilizó es X11() debajo UNIX,
ventanas() debajo Windows y cuarzo() bajo macOS. Un dispositivo nuevo siempre puede ser
abierto por dev.Nuevo().
Una vez el conductor de dispositivo está corriendo, R plotting las órdenes pueden
soler producir una variedad de exhibiciones gráficas y para crear enteramente clases
nuevas de exhibición..
Plotting Las órdenes están divididas a tres grupos básicos:
• Alto-nivelar plotting las funciones crean una parcela nueva en el dispositivo de gráfico,
posiblemente con hachas, etiquetas, títulos y tan encima.
• Abajo-nivelar plotting las funciones añaden más información a una parcela de
existir, como puntos extras, líneas y etiquetas..
• Funciones de gráfico interactivo te dejan interactivamente añadir información a, o
extracto infor- mation de, una parcela de existir, utilizando un dispositivo de señalar
como un ratón.
Además, R mantiene una lista de parámetros gráficos cuáles pueden ser manipulados para
personalizar vuestras parcelas.
Este manual único describes lo que un re known cuando ‘base' gráfico. Un gráfico
separado sub- el sistema en verja de paquete convive con base – es más potente pero más duro de
utilizar. Hay un enrejado de paquete recomendable (https://cran.r-
project.org/package=lattice) cuál construye encima verja y proporciona maneras de
producir multi-parcelas de tablero semejantes a aquellos en el sistema de Enrejado en S.
12.1 Alto-level plotting órdenes

Alto-nivelar plotting las funciones están diseñadas para generar una parcela completa del
dato pasó tan arguments a la función. Cuando proceda, hachas, las etiquetas y los títulos
son automáticamente generados (a no ser que pides otherwise.) Alto-nivelar plotting las
órdenes siempre empiezan una parcela nueva, borrando la parcela actual si es necesario..
12.1.1 La parcela() función

Uno del más frecuentemente utilizado plotting funciones en R es la parcela() función. Esto es un genérico
Función: el tipo de parcela produjo es dependiente en el tipo o clase del primer argumento.
Parcela(x, y)
Parcela(xy) Si x y y es vectores, parcela(x, y) produce un scatterplot de y contra x.
El mismo efecto puede ser producido por suministrador un argumento (forma de
segundo) cuando cualquiera una lista que contiene dos elementos x y y o una matriz
de dos columnas.
Parcela(x) Si x es una serie de tiempo, esto produce un tiempo-parcela de series. Si x es
un vector numérico, produce una parcela de los valores en el vector contra su
índice en el vector. Si x es un vector complejo, produce una parcela de
imaginario versus partes reales de los elementos de vector.
Parcela(
f)
parcela(f f Es un objeto de factor, y es un vector numérico. La primera forma genera una
, y) parcela de barra de f ; los segundos productos de forma boxplots de y para
cada nivel de f .
Capítulo 12: procedimientos 64
Gráficos
Parcela(df)
parcela(~
expr)
parcela(y ~
expr)
df Es un marco de dato, y es un ny object, expr es una lista de object los nombres
separaron by ‘+'
(P. ej., un + b + c). Las primeras dos formas producen parcelas distribucionales
de las variables en un marco de dato (primero forma) o de un número de nombró
objetos (forma de segundo). Las terceras parcelas de forma y contra cada objeto
nombrado en expr.
12.1.2 Displaying multivariate Dato

R Proporciona dos funciones muy útiles para representar multivariate dato. Si X es una
matriz numérica o marco de dato, la orden.
> Pares(X)
Productos un pairwise scatterplot la matriz de las variables definió por las columnas de X
, aquello es, cada columna de X es plotted contra cada otra columna de X y el
resultante n(n 1) las parcelas están arregladas en una matriz con constante de balanza− de
la parcela sobre las filas y columnas de la matriz.
Cuándo tres o cuatro variables están implicadas un coplot puede ser más enlightening. Si
un y b es vectores numéricos y c es un vector numérico u objeto de factor (todo de la
misma longitud), entonces la orden
> coplot(Un ~ b | c)
Productos un número de scatterplots de un en contra b para dado valora de c . Si c es un
factor, esto sencillamente significa que un es plotted contra b para cada nivel de c . Cuándo
c es numérico, está dividido a un número de condicionar intervalos y para cada intervalo
un es plotted contra b para valores de c dentro del intervalo. El número y la posición de
intervalos puede ser controlada con dado.Argumento= de valores a coplot() —la función
co.Intervalos() es útil para seleccionar intervalos. Puedes también uso dos variables
dadas con una orden gustan
> coplot(Un ~ b | c + d)
Qué productos scatterplots de un en contra b para cada intervalo de condicionante de la junta de cyd.
El coplot() y pares() función tanto tomar un tablero de argumento= cuáles pueden
soler personalizar el tipo de parcela qué aparece en cada tablero. El default es puntos() para
producir un scatterplot pero por suministrador algunos otra función de gráfico de nivel bajo de
dos vectores x y y como el valor de tablero= puedes producir cualquier tipo de parcela
deseas. Una función de tablero del ejemplo útil para coplots es tablero.Liso().
12.1.3 Display Gráfico

Otras funciones de gráfico de nivel alto producen tipos diferentes de parcelas. Algunos ejemplos son:
qqnorm(x)
qqline(x)
qqplot(x, y)
Distribución-parcelas de comparación. Las primeras parcelas de forma el
vector numérico x contra las puntuaciones de orden Normales esperadas (una
parcela de puntuaciones normal) y el segundo añade una línea recta a tal
parcela por dibujar una línea a través de la distribución y dato quartiles. Las
terceras parcelas de forma el quantiles de x contra aquellos de y para
comparar sus distribuciones respectivas.
hist(x)
hist(x, nclass=n)
hist(x, rompe=b, ...)
Productos un histograma del vector numérico x. Un número sensato de clases es
normalmente escogido, pero una recomendación puede ser dada con el
nclass= argumento. Alternativamente, el breakpoints puede ser especificado
exactamente con el argumento= de roturas.
Gráficos
Si la probabilidad=el argumento CIERTO está dado, las barras representan las

frecuencias relativas dividieron por ancho de cubo en vez de cuentas.
dotchart(x, ...)
Construye un dotchart del dato en x. En un dotchart el y-axial da un
etiquetando del dato en x y el x-axial da su valor. Por ejemplo deja
selección visual fácil de todas entradas de datos con valores lying en
especificó gamas.
Imagen(x, y, z, ...)
Contorno(x, y, z, ...)
persp(x, y, z, ...)
Parcelas de tres variables. La parcela de imagen dibuja una verja de los rectángulos
que utilizan colores diferentes para representar el valor de z , el contorno de
sorteos de parcela de contorno líneas para representar el valor de z , y el persp la
parcela dibuja una 3D superficie.
12.1.4 Unrguments a alto-nivelar plotting funciones

Hay un número de argumentos cuáles pueden ser pasados a alto-funciones de gráfico del
nivel, como sigue:
Añade=Fuerzas CIERTAS la función para actuar como función de gráfico de nivel
bajo, superponiendo la parcela en la parcela actual (algunos funciona únicos).
Las
hachas=FAL Suprime generación de las hachas—útiles para añadir vuestras hachas hecho propias con el
SAS Eje() función. El default, las hachas=CIERTAS, significa incluir hachas.
Registr
o="x"
registr
o="y"
Registro="xy" Causa el x, y o ambas hachas para ser logarítmicas. Esto trabajará
para muchos, pero no todo, tipos de parcela..
Tipo= El argumento= de tipo controla el tipo de parcela produjo, como sigue:.
Tipo="p" Parcela puntos individuales (el default)
Tipo="l" líneas de Parcela
Tipo="b" puntos de Parcela conectaron por líneas (ambos)
Tipo="o" puntos de Parcela overlaid por líneas
Tipo="h" Parcela líneas verticales de puntos al eje de cero (alto-densidad )
Tipo="s"
Tipo="S" Paso-parcelas de función. En la primera forma, la parte superior del
vertical define el punto; en el segundo, el fondo.
Tipo="n" No plotting en absoluto. Aun así las hachas son todavía dibujadas
(por default) y el sistema de coordenada está instalado según el
dato. Ideal para crear parcelas con funciones de gráfico de nivel
bajo subsiguientes.
xlab=Cuerda
ylab=cuerda
Etiquetas axiales para el x y y hachas. Uso estos argumentos para cambiar el
default etiquetas, normalmente los nombres de los objetos utilizaron en la
llamada al alto-nivelar plotting función.
Cuerda=principal
Título de figura, colocado en la parte superior de la parcela en una fuente grande.
sub=Cuerda
Sub-Título, colocado justo bajo el x-axial en una fuente más pequeña.
Gráficos
12.2 Low-nivelar plotting órdenes

A veces el alto-nivelar plotting las funciones no producen exactamente la clase de parcela
deseas. En este caso, abajo-nivelar plotting las órdenes pueden soler añadir
información extra (como puntos, líneas o texto) a la parcela actual.
Algunos del más útiles bajos-nivelar plotting las funciones son:
Puntos(x, y)
líneas(x, y)
Añade puntos o conectó líneas a la parcela actual. Parcela() es argumento= de
tipo también puede ser pasado a estas funciones (y defaults a "" p para puntos()
y l "" para líneas().)
Texto(x, y, etiquetas, ...)
Añade texto a una parcela en los puntos dados por x, y. Normalmente las
etiquetas es un entero o vector de carácter en qué etiquetas de caso[i] es
plotted en punto (x[i], y[i]). El default es 1:longitud(x).
Nota: Esta función es a menudo utilizada en la secuencia
> Parcela(x, y, tipo="n"); texto(x, y, nombres)
El tipo de parámetro del gráfico="n" suprime los puntos pero instala las
hachas, y el texto() la función suministra caracteres especiales, cuando
especificados por los nombres de vector del carácter para los puntos.
abline(Un, b)
abline(h=y)
abline(v=x)
abline(lm.obj)
Añade una línea de pendiente b e interceptar un a la parcela actual. h=y
Puede soler especificar y-coordenadas para las alturas de líneas horizontales
para ir a través de una parcela, y v= x de modo parecido para el x-coordenadas
para líneas verticales. También lm.obj Puede ser lista con un componente de
coeficientes de longitud 2 (como el resultado de funciones que caben modelo,)
cuáles están tomados como un interceptar y pendiente, en aquel orden.
Polígono(x, y, ...)
Sorteos un polígono definido por el ordenó vértices en (x, y) y
(opcionalmente) sombra él en con líneas de escotilla, o llenarlo si el
dispositivo de gráfico deja el relleno de figuras..
Leyenda(x, y, leyenda, ...)
Añade una leyenda a la parcela actual en la posición especificada. Plotting
Caracteres, estilos de línea, colores etc., está identificado con las etiquetas en la
leyenda de vector del carácter. Al menos uno otro argumento v (un vector
la misma longitud cuando leyenda) con el corre- sponding valores del plotting
la unidad también tiene que ser dada, como sigue:
Leyenda( , llena=v)
Colores para llenó cajas
Leyenda( , col=v)
Colores en qué puntos o las líneas serán dibujados
Leyenda( , lty=v)
Estilos de línea
Leyenda( , lwd=v)
Anchos de línea
Leyenda( , pch=v)
Plotting Caracteres (vector de carácter)
Gráficos
Título(principal, sub)
Añade un título principal hasta arriba de la parcela actual en una fuente
grande y (opcionalmente) un sub-título sub en el fondo en una fuente más
pequeña.
Eje(lado, ...)
Añade un axial a la parcela actual en el lado dado por el primer argumento (1 a 4,
contando en el sentido de las agujas del reloj de el fondo.) Otros argumentos
controlan el posicionamiento del axial dentro o junto a la parcela, y tick posiciones
y etiquetas. Útil para añadir hachas hechas de encargo después de llamar
parcela() con las hachas=argumento FALSO.
Abajo-nivelar plotting las funciones normalmente requieren alguna información de
posicionamiento (p. ej., x y y co- ordinates) para determinar dónde para colocar los
elementos de parcela nuevos. Las coordenadas están dadas en los plazos de usuario
coordina cuáles están definidos por la orden de gráfico de nivel alto anterior y está escogido
basado en el dato suministrado.
Dónde x y y los argumentos están requeridos, es también suficiente de suministrar un
argumento solo siendo una lista con los elementos nombraron x y y. De modo parecido
una matriz con dos columnas es también entrada válida. De este modo funciones como
locator() (ve abajo) puede soler especificar posiciones en una parcela interactivamente.
12.2.1 Mathematical anotación

En algunos casos, es útil de añadir símbolos matemáticos y formulae a una parcela. Esto
puede ser conseguido en R por especificar una expresión más que una cuerda de carácter en
cualquiera de texto , mtext, eje, o título . Por ejemplo, el código siguiente dibuja la fórmula
para la función de probabilidad Binomial:
> Texto(x, y, expresión(pasta(bgroup("(", atop(n, x), ")"), p^x, q^{n-x})))
Más información, incluyendo un listado lleno de las características la lata disponible
obtuvo de dentro de R utilizando las órdenes:
> Ayuda(plotmath)
> Ejemplo(plotmath)
> demo(plotmath)
12.2.2 Sushey fuentes de vector

Es posible de especificar Hershey fuentes de vector para rendering texto cuándo utilizando el texto y
contorno.
Funciones. Hay tres razones para utilizar el Hershey fuentes:
• Hershey Las fuentes pueden producir producción mejor, especialmente en una
pantalla de ordenador, para rotated y/o texto pequeño.
• Hershey Las fuentes proporcionan símbolos seguros que no puede ser disponible en
las fuentes estándares. En particular, hay señales de zodíaco, símbolos cartográficos
y símbolos astronómicos.
• Hershey Las fuentes proporcionan cyrillic y japanese (Kana y Kanji) caracteres.
Más información, incluyendo mesas de Hershey los caracteres pueden ser obtenidos
de dentro de R utilizando las órdenes:
> Ayuda(Hershey)
> demo(Hershey)
> Ayuda(japonés)
> demo(Japonés)
12.3 Yonteracting con gráficos.

R También proporciona funciona cuáles dejan usuarios para extraer o añadir información
a una parcela que utiliza un ratón. El más sencillo de estos es el locator() función:
Gráficos
locator(n, tipo)
Esperas para el usuario para seleccionar ubicaciones en la parcela actual que
utiliza el botón de ratón izquierdo. Esto continúa hasta n (default 512) los
puntos han sido seleccionados, u otro botón de ratón está pulsado. El
argumento de tipo deja para plotting en el seleccionó puntos y tiene el mismo
efecto en cuanto a órdenes de gráfico de nivel alto; el default es no plotting.
locator() Regresa las ubicaciones de los puntos seleccionaron como lista con
dos componentes x y y.
locator() Es normalmente llamado sin argumentos. Es particularmente útil para
interactivamente seleccionando posiciones para elementos gráficos como leyendas o etiquetas
cuándo es difícil de calcular por adelantado dónde el gráfico tendría que ser colocado. Por
ejemplo, para colocar algunos texto informativo cerca un outlying punto, la orden.
> Texto(locator(1), "Outlier", adj=0)
Puede ser útil. (locator() Será ignorado si el dispositivo actual, como la posdata no
apoya interactiva señalando.)
Identifica(x, y, etiquetas)
Dejar el usuario para destacar cualquiera de los puntos definió por x y y
(utilizando el botón de ratón izquierdo) por plotting el componente
correspondiente de las etiquetas cercanas (o el número de índice del punto
si las etiquetas es ausentes). Regresos los índices del seleccionó puntos
cuándo otro botón está pulsado.
A veces queremos identificar puntos particulares en una parcela, más que sus
posiciones. Por ejemplo, podemos desear el usuario para seleccionar alguna observación
de interés de una exhibición gráfica y entonces manipular aquella observación en alguna
manera. Dado un número de ( x, y) coordenadas en dos vectores numéricos x y y,
podríamos utilizar el identificar() funciona como sigue:.
> Parcela(x, y)
> Identifica(x, y)
El identificar() las funciones actúa no plotting él, pero sencillamente deja el
usuario para mover el puntero de ratón y clic el botón de ratón izquierdo cerca un punto. Si
hay un punto cerca el ratón pointer lo be munrked con su índice number (then es, su
position en el x/y vectors) plotted cercano. Alternativamente, podrías utilizar algunos
cuerda informativa (como un nombre de caso) como punto destacado por utilizar el
argumento de etiquetas para identificar(), o inutilizar marcando altogether con la
parcela = argumento FALSO. Cuándo el proceso está rescindido (ve encima),
identifica() regresa los índices del seleccionó puntos; puedes utilizar estos índices para
extraer el seleccionó puntos de los vectores originales x y y.
12.4 UCanta parámetros de gráfico

Cuándo creando gráfico, particularmente para presentación o propósitos de publicación,
R defaults no siempre produce exactamente aquello cuál está requerido. Puedes, aun así,
personaliza casi cada aspecto de la exhibición que utiliza parámetros de gráfico. R
Mantiene una lista de un número grande de parámetros de gráficos qué cosas de control
como estilo de línea, colores, arreglo de figura y texto justifica- tion entre many otros.
Every Gráfico parsoyeter tiene un nombre (such cuando ‘col', which controls colores,) y
un valor (un número de color, por ejemplo.).
Una lista separada de parámetros de gráficos está mantenida para cada dispositivo
activo, y cada dispositivo tiene un default conjunto de los parámetros cuándo
inicializados. Parámetros de gráfico pueden ser puestos en dos maneras: cualquiera
permanentemente, afectando todos los gráficos funciona cuáles acceden el dispositivo
actual; o temporalmente, afectando sólo una llamada de función de gráfico sola.
12.4.1 Permanent Cambios: El par() función

El par() la función suele acceso y modificar la lista de parámetros de gráficos para el
dispositivo de gráfico actual.
Gráficos
par() Sin argumentos, regresa una lista de todos parámetros de gráficos y sus valores
para el dispositivo actual.
par(c("col", "lty"))
Con un argumento de vector del carácter, regresa sólo los parámetros de
gráfico nombrados (otra vez, como lista.)
par(col=4, lty=2)
Con nombró argumentos (o un argumento de lista solo), pone los valores de
los parámetros de gráfico nombrados, y regresa los valores originales de los
parámetros como lista.
Poniendo parámetros de gráfico con el par() la función cambia el valor de los parámetros
permanentemente, en el sentido que todas las llamadas futuras a funciones de gráfico (en el
dispositivo actual) será afectado por el valor nuevo. Puedes pensar de poner parámetros
de gráfico de este modo tan poniendo “default” valores para los parámetros, el cual será
utilizado por todas funciones de gráficos a no ser que un valor alternativo está dado.
Nota que llamadas a par() siempre afectar los valores globales de parámetros de
gráficos, incluso cuándo par() se apellida de dentro de una función. Esto es a menudo
comportamiento indeseable—normalmente queremos puestos algunos parámetros de gráfico,
algún plotting, y entonces restaurar los valores originales tan cuando no para afectar el
usuario R sesión. Puedes restaurar los valores iniciales por salvar el resultado de par()
cuándo haciendo cambios, y restaurando los valores iniciales cuándo plotting es completo.
> oldpar <- par(col=4, lty=2)
. . . plotting Órdenes . . .
> par(oldpar)
Para salvar y restaurar todo settable1 parámetros gráficos uso
> oldpar <- par(Ningún.readonly=CIERTO)
. . . plotting Órdenes . . .
> par(oldpar)
12.4.2 Temporary Cambios: Argumentos a funciones de gráfico
Parámetros de gráfico también pueden ser pasados a (casi) cualquier función de gráfico
cuando nombró argumentos. Esto tiene el mismo efecto cuando pasando los argumentos al
par() función, exceptúa que los cambios sólo último para la duración de la llamada de
función. Por ejemplo:.
> Parcela(x, y, pch="+")
Productos un scatterplot utilizando una señal de plus como el plotting carácter, sin
cambiar el default plotting carácter para parcelas futuras.
Desafortunadamente, esto no es implementado enteramente coherentemente y es a
veces necesario de poner y parámetros de gráfico de la reinicialización que utilizan
par().
12.5 Graphics lista de parámetros

Las secciones siguientes detallan muchos del generalmente-parámetros gráficos utilizados. El
R documentación de ayuda para el par() la función proporciona un resumen más
conciso; esto está proporcionado como un poco alternativa más detallada.
Parámetros de gráfico serán presentados en la forma siguiente:
Valor=de nombre
Una descripción del efecto del parámetro. El nombre es el nombre del
parámetro, aquello es, el nombre de argumento para utilizar en llamadas a
par() o una función de gráfico. El valor es un valor típico podrías utilizar
cuándo poniendo el parámetro.
Nota que las hachas no es un parámetro de gráfico pero un argumento a unos cuantos métodos
de parcela: ve
xaxt Y yaxt .
1
Algunos parámetros de gráfico como la medida del dispositivo actual es para información sólo.
Gráficos
12.5.1 Elementos gráficos

R Las parcelas están hechas de puntos, líneas, texto y polígonos (llenó regiones.) Los
parámetros gráficos existen qué control cómo estos elementos gráficos están dibujados,
como sigue:
pch="+" Carácter para ser utilizado para plotting puntos. El default varía con
conductores de gráficos,
◦ pero es normalmente ‘ '. Plotted Los puntos tienden para
aparecer ligeramente encima o bajo la posición apropiada a no ser que utilizas
"." Cuando el plotting carácter, el cual produce centró puntos.
pch=4 Cuándo pch está dado como un entero entre 0 y 25 inclusive, un especializado
plotting el símbolo está producido. Para ver lo que los símbolos son, uso la orden
> Leyenda(locator(1), cuando.Carácter(0:25), pch = 0:25)
Aquellos de 21 a 25 puede aparecer para duplicar símbolos más tempranos,
pero puede ser pintado en maneras diferentes: ver la ayuda en puntos y
sus ejemplos.
Además, pch puede ser un carácter o un número en la gama 32:255
representando un carácter en la fuente actual.
lty=2 tipos de Línea. Estilos de línea alternativa no son apoyados encima todos
dispositivos de gráficos (y variar encima los que hacen) pero tipo de línea 1 es
siempre una línea sólida, tipo de línea 0 es siempre invisible, y la línea escribe 2
y en adelante es salpicado o dashed líneas, o alguna combinación de ambos..
lwd=2 anchos de Línea. Ancho deseado de líneas, en múltiplos del “ancho” de línea
estándar. Afecta líneas axiales así como las líneas dibujadas con líneas() , etc.
No todos los dispositivos apoyan esto, y algunos tienen restricciones en los
anchos que puede ser utilizado.
col=2 Colores para ser utilizados para puntos, líneas, texto, llenó regiones e imágenes.
Un número de la paleta actual (ve ?Paleta) o un color nombrado.
col.Axia
l
col.Lab
oratori
o
col.Prin
cipal
col.sub El color para ser utilizado para anotación axial, x y y etiquetas, principales y sub-
títulos, respectively.
Fuente=2 Un entero qué especifica qué fuente para utilizar para texto. Si es posible,
conductores de dispositivo arreglan de modo que 1 corresponde a texto sencillo,
2 a cara intrépida, 3 a italic, 4 a intrépido italic y 5 a una fuente de símbolo
(cuáles incluyen letras griegas).
Fuente.Fuente
axial.Fuente
de
laboratorio.P
rincipal
Fuente.sub La fuente para ser utilizada para anotación axial, x y y etiquetas, principales y
sub-títulos, respectively.
adj=-0.1 Justificación de pariente de texto al plotting posición. 0 significa a la izquierda
justificar, 1 significa bien justificar y 0.5 significa para centrar horizontalmente
sobre el plotting posición. El valor real es la proporción de texto que aparece a la
izquierda del plotting posición, así que un valor de -0.1 hojas un vacío de 10%
del ancho de texto entre el texto y el plotting posición.
cex=1.5 expansión de Carácter. El valor es la medida deseada de caracteres de texto
(incluyendo plotting caracteres) pariente a el default medida de texto.
Gráficos
cex.Axia
l
cex.Lab
oratori
o
cex.Prin
cipal
cex.sub La expansión de carácter para ser utilizado para anotación axial, x y y etiquetas,
principales y sub-títulos, respectivamente.
12.5.2 Unxes y tick marcas

Muchos de R parcelas de nivel alto tienen hachas, y puedes construir hachas tú con el eje de
nivel bajo() función de gráfico. Las hachas tienen tres componentes principales: la línea
axial (estilo de línea controlado por el lty parámetro de gráfico), el tick marcas (cuáles
marcan fuera divisiones de unidad a lo largo de la línea axial) y el tick etiquetas (cuáles
marcan las unidades.) Estos componentes pueden ser personalizados con los parámetros de
gráfico siguientes.
Laboratorio=c(5, 7, 12)
Los primeros dos números son el número deseado de tick intervalos en el x y
y hachas respectivamente. El tercer número es la longitud deseada de
etiquetas axiales, en caracteres (incluyendo el punto decimal.) Escogiendo un
demasiado-el valor pequeño para este parámetro puede resultar en todo tick
etiqueta ser redondeado al mismo número!
las=1 Orientación de etiquetas axiales. 0 significa siempre paralelo a eje, 1 significa

siempre horizonte- tal, y 2 significa siempre perpendicular al eje.
mgp=c(3, 1, 0)
Posiciones de componentes axiales. El primer componente es la distancia de
la etiqueta axial a la posición axial, en líneas de texto. El segundo
componente es la distancia a el tick etiquetas, y el componente final es la
distancia de la posición axial a la línea axial (normalmente cero). Medida de
números positivos fuera de la región de parcela, interior de números
negativos.
tck=0.01 Longitud de tick marcas, como fracción de la medida del plotting región. Cuándo
tck es pequeño (menos de 0.5) el tick marcas en el x y y las hachas están
forzadas para ser la misma medida. Un valor de 1 da líneas de verja. Los valores
negativos dan tick marcas fuera del plotting región. Uso tck=0.01 y mgp=c(1,-
1.5,0) para interno tick marcas.
xaxs="r"
yaxs="i" Estilos axiales para el x y y hachas, respectivamente. Con estilos "i"
(internos) y r "" (el default) tick marcas siempre caída dentro de la gama del
dato, aun así estilo "r" deja una cantidad pequeña de espacial en los bordes. (S
Tiene otros estilos no implementados en R.)
12.5.3 Márgenes de figura

Una parcela sola en R es sabido como figura y comprende una región de parcela
rodeada por márgenes (posiblemente conteniendo etiquetas axiales, títulos, etc.) y
(normalmente) acotados por las hachas ellos.
Gráficos
Una figura típica es
−−−−−−−−−−−−−−−−−−
−−−−−−−−−−−−−−−−−−
−−−−−−−−−−−−−−−−−−
−−−−−−−−−−−−−−−−−− mar[3]
−−−−−−−−−−−−−−−−−−
−−−−−−−−−−−−−−−−−−
Región de parcela
mai[2]
3.0
1.5
−3.0 −1.5 0.0 1.5 3.0

0.0
y
mai[1] x
Marge
n
−1.5
−3.0
Parámetros de gráfico que controlan diseño de figura incluye:
mai=c(1, 0.5, 0.5, 0)

Anchos del fondo, a la izquierda, parte superior y márgenes correctos, respectivamente,
medidos en pulgadas.
mar=c(4, 2, 2, 1)
Similar a mai , excepto la unidad de medida es líneas de texto .
mar Y mai es equivalente en el sentido que encuadre uno cambia el valor del otro. El
default los valores escogidos para este parámetro es a menudo demasiado grande; el margen
derecho es raramente necesitado, y tampoco es el margen superior si ningún título está
siendo utilizó. Los márgenes inferiores e izquierdos tienen que ser bastante grandes para
acomodar el axial y tick etiquetas. Además, el default está escogido sin considerar a la
medida de la superficie de dispositivo: por ejemplo, utilizando la posdata() conductor con la
altura=4 argumento resultará en una parcela qué es aproximadamente 50% margen a no ser que
mar o mai está puesto explícitamente. Cuándo las figuras múltiples son en uso (ve abajo) los
márgenes están reducidos, aun así esto no puede ser bastante cuándo muchas figuras comparten
la misma página.
Gráficos
12.5.4 Multiple entorno de figura

R Te dejas para crear un n por m variedad de figuras en una página sola. Cada figura
tiene sus márgenes propios, y la variedad de figuras es opcionalmente rodeado por un
margen exterior, cuando mostrado en la figura siguiente.
−−−−−−−−−−−−−−−
−−−−−−−−−−−−−−−
−−−−−−−−−−−−−−− oma[3]
−−−−−−−−−−−−−−−
−−−−−−−−−−−−−−−
omi[4]
mfg=c(3,2,3,2)
omi[1]
mfrow=c(3,2)
Los parámetros gráficos que relacionan a las figuras múltiples son como sigue:
mfcol=c(3, 2)
mfrow=c(2, 4)
Pone la medida de una variedad de figura múltiple. El primer valor es el número
de filas; el segundo es el número de columnas. La diferencia única entre estos
dos parámetros es que poniendo mfcol las causas representa para ser llenados
por columna; mfrow llena por filas.
El diseño en la Figura podría haber sido creado por poner mfrow=c(3,2); la
figura muestra la página después de que cuatro parcelas han sido dibujadas.
Poniendo tampoco de estos pueden reducir la medida de base de símbolos y
texto (controlados por par("cex") y el pointsize de el dispositivo). En un
diseño con exactamente dos filas y columnas la medida de base está reducida
por un factor de 0.83: si hay tres o más de cualesquier filas o columnas, el
factor de reducción es 0.66.
mfg=c(2, 2, 3, 2)
Posición de la figura actual en un entorno de figura múltiple. Los primeros dos
números son la fila y columna de la figura actual; el últimos dos son el número
de filas y columnas en la variedad de figura múltiple. Pone este parámetro para
saltar entre figuras en la variedad. Incluso puedes utilizar valores diferentes para los
últimos dos números que los valores ciertos para unequally-sized figuras en la
misma página.
Higo=c(4, 9, 1, 4)/10
Posición de la figura actual en la página. Los valores son las posiciones del
izquierdos, bien, fondo y bordes superiores respectivamente, como porcentaje de la
página medida de la esquina izquierda inferior. El valor de ejemplo sería para
una figura en el derecho inferior de la página. Pone este parámetro para
posicionamiento arbitrario de figuras dentro de una página. Si quieres añadir
una figura a una página actual, el uso nuevo=CIERTO también (a diferencia de
S)..
oma=c(2, 0, 3, 0)
omi=c(0, 0, 0.8, 0)
Medida de márgenes exteriores. Como mar y mai , las primeras medidas en
líneas de texto y el segundo en pulgadas, empezando con el margen inferior y
trabajando en el sentido de las agujas del reloj.
Gráficos
Los márgenes exteriores son particularmente útiles para página-títulos sensatos, etc. el
texto puede ser añadido a los márgenes exteriores con el mtext() función con el
argumento exterior=CIERTO. hay no márgenes exteriores por default, aun así, así que
les tienes que crear explícitamente utilizando oma u omi.
Más complicó los arreglos de figuras múltiples pueden ser producidos por la
ruptura.Pantalla() y diseño() funciones, así como por la verja y enrejado
(https://cran.r-project.org/ enrejado=de paquete) paquetes.
12.6 DevConductores de hielo

R Puede generar gráfico (de niveles variables de calidad) encima casi cualquier tipo de
exhibición o imprimiendo dispositivo. Antes de que esto puede empezar, aun así, R
necesidades de ser informadas qué tipo de dispositivo está tratando. Esto está hecho por
empezar un conductor de dispositivo. El propósito de un conductor de dispositivo es
para convertir instrucciones gráficas de R (“sorteo una línea,” por ejemplo) a una forma que
el dispositivo particular puede entender.
Conductores de dispositivo están empezados por llamar una función de conductor del
dispositivo. Hay uno tal función para cada conductor de dispositivo: ayuda de
tipo(Dispositivos) para una lista de ellos todo. Por ejemplo, emitiendo la orden
> Posdata()
Causa toda producción de gráfico futura para ser enviado a la impresora en formato de
Posdata. Algunos dispositivo generalmente utilizado los conductores son:
X11() Para uso con la X11 ventana sistema encima Unix-alikes
Ventanas()
Para utilizar encima Windows
Cuarzo() Para uso en macOS
Posdata()
Para imprimir encima impresoras de Posdata, o creando archivos de gráfico de la Posdata.
Pdf() Produce un archivo de PDF, los cuales también pueden ser incluidos a archivos de PDF.
png() Produce un bitmap PNG archivo. (No siempre disponible: ver su página de ayuda.)
jpeg() Produce un bitmap JPEG archivo, más utilizado para parcelas de imagen. (No
siempre disponible: ver su página de ayuda.)
Cuándo has acabado con un dispositivo, ser seguro para rescindir el conductor de
dispositivo por emitir la orden
> dev.Fuera()
Esto asegura que las llegadas de dispositivo cleanly; por ejemplo en el caso de
hardcopy dispositivos este asegura que cada página está completada y ha sido enviado a
la impresora. (Esto pasará automáticamente en el fin normal de una sesión.)
12.6.1 PostScript Esquemas para typeset documentos

Por pasar el argumento de archivo a la posdata() función de conductor del dispositivo,
puedes almacenar el gráfico en formato de Posdata en un archivo de vuestra elección. La parcela
será en orientación de paisaje a no ser que el argumento=FALSO horizontal está dado, y
puedes controlar la medida del gráfico con el ancho y argumentos de altura (la parcela será
scaled tan apropiado de caber estas dimensiones.) Por ejemplo, la orden.
> Posdata("file.ps", horizontal=FALSO, altura=5, pointsize=10)
Producirá un archivo que contiene código de Posdata para una figura cinco pulgadas alto,
quizás para inclusión en un documento. Es importante de notar que si el archivo
nombrado en la orden ya existe,
Gráficos
Sea overwritten. Esto es el caso incluso si el archivo era sólo creado más temprano en
el mismo R sesión.
Muchos usos de producción de Posdata serán para incorporar la figura en otro
documento. Esto trabaja más cuándo encapsulated la posdata está producida: R siempre
produce conformant producción, pero sólo marca la producción como tal cuando el
onefile=el argumento FALSO está suministrado. Estas raíces de notación inusuales
de S-compatibilidad: realmente significa que la producción será una página sola (cuál
es parte del EPSF especificación). Así para producir una parcela para inclusión utiliza a
algo le gusta
> Posdata("parcela1.eps", horizontal=FALSO, onefile=FALSO,
altura=8, ancho=6, pointsize=10)
12.6.2 Multiple dispositivos de gráfico

En uso adelantado de R es a menudo útil de tener varios dispositivos de gráfico en utilizar al
mismo tiempo. Naturalmente sólo un dispositivo de gráfico puede aceptar órdenes de gráfico
a la vez, y esto es sabido como el dispositivo actual. Cuándo los dispositivos múltiples
son abiertos, forman una secuencia numerada con los nombres que dan la clase de
dispositivo en cualquier posición.
Las órdenes principales utilizaron para operativos con dispositivos múltiples, y sus
significados son como sigue:.
X11() [UNIX]
Ventanas()
gana.Impresora()
gana.metafile()
[Windows]
Cuarzo() [macOS]
Posdata()
pdf()
png()
jpeg()
tiff()
bitmap()
... Cada llamada nueva a una función de conductor del dispositivo abre un dispositivo
de gráfico nuevo, por ello extendiendo por uno la lista de dispositivo. Este
dispositivo deviene el dispositivo actual , a qué producción de gráfico será
enviada.
dev.Lista(
) Regresos el número y nombre de todos los dispositivos activos. El dispositivo
en posición 1 en la lista es siempre el null dispositivo cuál no acepta órdenes
de gráfico en absoluto..
dev.Luego(
) Regresos el número y nombre del dispositivo de gráfico luego a, o anterior al
dev.prev() dispositivo actual, respectivamente.
dev.Conjunto(qué=k)
Puede soler cambiar el dispositivo de gráfico actual al en posición k de la
lista de dispositivo. Regresos el número y etiqueta del dispositivo.
dev.Fuera(
k) Rescindir el dispositivo de gráfico en punto k de la lista de dispositivo. Para
algunos dispositivos, como dispositivos de posdata, esto tampoco
imprimirá el archivo inmediatamente o correctamente completar el archivo
para impresión más tardía, dependiendo de cómo el dispositivo estuvo
iniciado.
Gráficos
dev.Copia(dispositivo, ..., El
cual=k)
dev.Impresión(dispositivo, ...,
El cual=k)
Marca una copia del dispositivo k. Aquí el dispositivo es una función de dispositivo , como
posdata,
Con extra arguments, si necesitado, specified by ‘...'. dev.La impresión es
similar, pero el dispositivo copiado es inmediatamente cerrado, de modo que
acciones de fin, como imprimir hardcopies, es inmediatamente actuó.
Gráfico.Fuera()
Rescindir todos dispositivos de gráficos en la lista, excepto el null dispositivo.
12.7 Dynamic Gráfico

R No tiene builtin capacidades para gráfico dinámico o interactivo, p. ej. rotating nubes de
punto o a “cepillar” (interactivamente destacando) puntos. Aun así, instalaciones de gráfico
dinámicas extensas son disponibles en el sistema GGobi por Swayne, Cocinero y Buja
disponible de
http://www.ggobi.org/
Y estos pueden ser accedidos de R vía el paquete rggobi (https://cran.r-project.org/
paquete=rggobi), descrito en http://www.ggobi.org/rggobi.
También, paquete rgl (https://cran.r-project.org/package=rgl) proporciona
maneras de interaccionar con 3D parcelas, por ejemplo de superficies.
77
13 Packages
Todo R funciones y datasets está almacenado en paquetes. Sólo cuándo un paquete es cargado
es sus contenidos disponibles. Esto está hecho ambos para eficacia (la lista llena tomaría más
memoria y tomaría más largo de buscar que un subconjunto), y a desarrolladores de paquete
de la ayuda, quiénes están protegidos de enfrentamientos de nombre con otro código. El proceso
de paquetes en desarrollo está descrito en la sección que “Crea R paquetes” en Escribir R
Extensiones. Aquí, les describiremos del punto de vista de un usuario..
Para ver qué paquetes están instalados en vuestro sitio, asunto la orden
> Biblioteca()
Sin argumentos. Para cargar un paquete particular (p. ej., la bota (https://CRAN.R-
Proyecto. org/Bota=de paquete) el paquete que contiene funciones de Davison &
Hinkley (1997)), uso un com- mand gusta
> Biblioteca(bota)
Los usuarios conectaron a el Internet puede utilizar el instalar.Paquetes() y
actualización.Paquetes() funciones (disponibles a través de la carta de Paquetes en el
Windows y macOS GUIs, ve Sección “Instalando paquetes” en R Instalación y Administración)
para instalar y paquetes de actualización.
Para ver qué paquetes son actualmente cargados, uso
> Búsqueda()
Para mostrar la lista de búsqueda. Algunos paquetes pueden ser cargados pero no disponibles
en la lista de búsqueda (ve Sección 13.3 [Namespaces], página 78): estos serán incluidos en
la lista dada por
> loadedNamespaces()
Para ver una lista de todos temas de ayuda disponibles en un paquete instalado, uso
> Ayuda.Inicio()
Para empezar el sistema de ayuda del HTML, y entonces navigate al listado de paquete en la
Referencia
Sección.
13.1 Paquetes estándares

El estándar (o base ) los paquetes están considerados parte del R código de fuente.
Contienen las funciones básicas que deja R para trabajar, y el datasets y funciones
estadísticas y gráficas estándares que está descrito en este manual. Tendrían que ser
automáticamente disponibles en cualquier R instalación. Ve Sección “R paquetes” en R
FAQ, para una lista completa.
13.2 Contributed Paquetes y CRAN.

Hay miles de contribuyó paquetes para R, escritos por muchos autores diferentes.
Algunos de estos paquetes implementan métodos estadísticos especializados, otros dan acceso a
dato o duro- ware, y otros están diseñados para complementar textbooks. Algunos (los
paquetes recomendables) está distribuido con cada distribución binaria de R. La mayoría es
disponible para descarga de CRAN (https://cran.r-project.org/ y sus espejos) y
otros repositorios como Bioconductor (https://www.bioconductor.org/). Y Omegahat
(http://www.omegahat.net/). El R FAQ contiene una lista de CRAN corriente de paquetes
en el tiempo de liberación, pero la colección de paquetes disponibles cambia muy
frecuentemente.
Capítulo 13: 78
Paquetes
13.3 Namespaces
Paquetes haber namespaces, el cual tres cosas: dejan el escritor de paquete para esconder
funciones y dato que está significado sólo para uso interno, impiden funciones de
romper cuándo un usuario (u otro escritor de paquete) elige un nombre que
enfrentamientos con uno en el paquete, y proporcionan una manera de referir a un objeto
dentro de un paquete particular.
Por ejemplo, t() es el transpose función en R, pero los usuarios podrían definir su
función propia nombró t. Namespaces Impide la definición del usuario de tomar precedencia,
y rompiendo cada función que prueba a transpose una matriz.
Hay dos operadores que trabajo con namespaces. El operador de colon doble ::
selecciona definiciones de un particulares namespace. En el ejemplo encima, el transpose la
función siempre será disponible cuando base::t, porque está definido en el paquete
de base. Sólo funciona aquello está exportado de el paquete puede ser recuperado de este
modo..
El operador de colon triple ::: puede ser visto en unos cuantos sitios en R código: actúa
como el operador de colon doble pero también deja acceso a escondido objeta. Los usuarios
son más probablemente para utilizar el getAnywhere() función, el cual busca paquetes
múltiples.
Los paquetes son a menudo inter-dependientes, y cargando un puede causar otros para
ser automáticamente cargados. Los operadores de colon describieron encima también
causará automático cargando de el paquete asociado. Cuándo paquetes con namespaces
está cargado automáticamente no son añadidos a la lista de búsqueda.
79
14 OS Instalaciones
R Tiene instalaciones bastante extensas para acceder el OS debajo cuál está corriendo:
esto lo deja para ser utilizado como scripting lengua y que la capacidad es mucho
utilizada por R él, por ejemplo para instalar paquetes.
Porque R necesidad de guiones propios para trabajar a través de todas las plataformas, el
esfuerzo considerable ha ido a hacer el scripting instalaciones cuando plataforma-
independiente cuando es factible.
14.1 Archivos y directorios.

Hay muchos funciona para manipular archivos y directorios. Aquí es punteros a algunos
del más generalmente utilizó unos.
Para crear un (vacío) archivo o directorio, archivo de uso.Crea o dir.Crea . (Estos son los
equivalentes del POSIX tacto de utilidades y mkdir .) Para directorios y archivos
provisionales en el R directorio de sesión ve tempfile.
Los archivos pueden ser sacados por cualquier archivo.Saca o unlink : el último puede
sacar árboles de directorio.
Para lista de uso de listados de directorio.Archivos (también disponibles cuando
dir) o lista.dirs . Estos pueden seleccionar los archivos que utilizan una expresión regular: para
seleccionar por wildcards uso Sys.glob.
Muchos tipos de información en un filepath (incluyendo por ejemplo si es un archivo o
directorio) puede ser encontrado por file.info.
Hay varias maneras de descubrir si un archivo ‘existe' (un archivo puede existir en el filesystem y
no ser visible al usuario actual). Hay archivo de funciones.Existe, archivo.Acceso
y prueba_de archivo con varias versiones de esta prueba: prueba_de archivo es una versión
del POSIX orden de prueba para aquellos familiar con concha scripting.
Archivo de función.La copia es el R equivalente del POSIX orden cp.
Escogiendo los archivos pueden ser hechos interactivamente por archivo.Escoge: el
puerto de Windows tiene las funciones más versátiles escogen.Archivos y escoger.dir Y
hay funciones similares en el tcltk paquete: tk_escoge.Archivos y tk_escoge.dir .
Archivo de funciones.Espectáculo y archivo.Edita mostrará y editar uno o más
archivos en una manera appro- priate al R puerto, utilizando las instalaciones de una consola
(como RGui encima Windows o R.Aplicación en macOS) si uno es en uso.
Hay algún soporte para enlaces en el filesystem: ve archivo de funciones.Enlace y Sys.readlink .
14.2 Filepaths
Con unas cuantas excepciones, R confía en el subyacente OS funciones para manipular
filepaths. Algunos aspectos de este está dejado para depender de el OS, y , incluso abajo
a la versión del OS. hay POSIX estándares para cómo OSes tendría que interpretar
filepaths y muchos R los usuarios suponen POSIX conformidad: pero Windows no
reclama para ser compliant y otro OSes puede ser menos de completamente compliant.
El siguiente es algunos emite cuáles han sido encontrados con filepaths.
• POSIX filesystems Es caso-sensible, tan foo.png Y Foo.PNG Es archivos diferentes.
Aun así, el defaults encima Windows y macOS es para ser caso-insensible, y GORDO
filesystems (com- monly utilizado en almacenamiento desmontable) no es normalmente
caso-sensible (y todo filepaths puede ser mapped para bajar caso).
• Casi todo el Windows' OS los servicios apoyan el uso de cuchillada o backslash como el
filepath separator, y R convierte las excepciones sabidas a la forma requerida por
Windows.
Capítulo 14: OS 80
instalaciones
• El comportamiento de filepaths con una cuchillada final es OS-dependiente. Tales

caminos no son válidos encima Windows y no tendría que ser esperado para trabajar.
POSIX-2008 requiere tales caminos para emparejar directorios únicos, pero las
versiones más tempranas les dejaron a también archivos de partido. Así que son más
evitó.
• Múltiple acuchilla en filepaths como /abc//def es válido en POSIX filesystems y
tratado como si había sólo uno acuchilla. Son normalmente aceptados por Windows'
OS funciones. Aun así, dirigiendo doble acuchilla puede tener un significado diferente.
• Windows' UNC filepaths (como \\servidor\dir1\dir2\archivo y
\\?\UNC\Servidor\dir1\dir2\archivo) no es apoyado, pero pueden
trabajar en algún R funciones. POSIX filesystems Está dejado para tratar una cuchillada
doble principal especialmente. Windows deja filepaths conteniendo paseos y relativos a
• el directorio actual en un paseo,
P. ej. d:foo/la barra refiere a d:/un/b/c/foo/barra si el directorio actual encima paseo d:
es /un/b/c. Está pretendido que este trabajo, pero el uso de caminos absolutos es más
seguro.
Funciones basename y dirname seleccionar partes de un camino de archivo: la manera
recomendable a tan- semble un camino de archivo de componentes es archivo.Camino.
Función pathexpand ‘tilde expansión', sustituyendo valores para directorios de casa (el
usuario actual es, y quizás aquellos de otros usuarios).
En filesystems con enlaces, un en fila india puede ser referido a por muchos filepaths. Función
normalizePath Encontrará un canónico filepath.
Windows tiene los conceptos de cortos (‘8.3') y nombres de archivo largo: normalizePath
regresará un camino absoluto que utiliza nombres de archivo largo y shortPathName regresará
una versión que utiliza nombres cortos. El último no contiene espacios y usos backslash como
el separator, así que es a veces útil para nombres exportadores de R..
Permisos de archivo son un tema relacionado . R Tiene soporte para el POSIX
conceptos de leer/escribir/ejecutar el permiso para dueño/agrupa/todos pero esto pueden
ser sólo parcialmente apoyados en el filesystem, tan por ejemplo encima Windows sólo
leído-archivos únicos (para la cuenta que corre el R sesión) está reconocido. Listas de
Control del acceso (ACLs) está empleado en varios filesystems, pero no tiene un estándar
acordado y R tiene ninguna instalación para controlarles. Uso Sys.chmod Para cambiar
permisos.
14.3 SyÓrdenes de raíz

Sistema de funciones y sistema2 suele invocar una orden de sistema y opcionalmente
recoger su producción. Sistema2 es un poco más general pero su ventaja principal es que
es más fácil de escribir cruz-código de plataforma que lo utiliza.
Sistema behaves de manera diferente encima Windows de otro OSes (porque el API C
llamada de aquel nombre ). En otro lugar invoca una concha para correr la orden: el puerto
de Windows de R tiene una concha de función para hacer que.
Para descubrir si el OS incluye una orden, uso Sys.Qué, el cual intenta para hacer este en
una cruz-manera de plataforma (desafortunadamente no es un estándar OS servicio).
Función shQuote citará filepaths tan necesitado para órdenes en el actuales OS.
14.4 Compression Y Archivos.

Versiones recientes de R tiene instalaciones extensas para leer y escribir comprimió archivos, a
menudo transpar- ently. Lectura de archivos en R es a un vey la extensión grande hecha por
conexiones, y el archivo funciona cuál suele abrir una conexión a un archivo (o un URL) y
es capaz de identificar la compresión utilizada del ‘mágico' encabezamiento del archivo.
El tipo de compresión qué se tiene mantenido para más largo es gzip compresión, y
aquello queda un bueno general compromise. Los archivos comprimieron por el Unix más
temprano comprime la utilidad también puede ser leída, pero estos están deviniendo raros.
Dos otras formas de compresión, aquellos del.
Capítulo 14: OS 81
instalaciones
bzip2 y xz las utilidades son también disponibles. Estos generalmente consiguen índices
más altos de compresión (dependiendo de el archivo, mucho más alto) a expensas de
descompresión más lenta y mucha compresión más lenta.
Hay alguna confusión entre xz y lzma compresión (ve https://en.wikipedia.
org/wiki/Xz Y https://en.wikipedia.org/wiki/lzma ): R puede leer los archivos comprimieron por
más versiones de cualquier..
Archivos de archivo son archivos solos qué contener una colección de archivos, la
mayoría de comunes unos siendo ‘tarballs' y la cremallera archiva tan utilizada para distribuir
R paquetes. R Puede listar y desempaquetar ambos (ve funciones untar y unzip ) y crear
ambos (para cremallera con la ayuda de un programa externo).
82
Apéndice Una Una sesión de muestra

La sesión siguiente está pretendida para introducir a ti algunos presenta del R entorno por
utilizarles. Muchas características del sistema serán unfamiliar y puzzling al principio,
pero este puzzlement pronto desaparecerá.
Inicio R apropiadamente para vuestra plataforma (ve Apéndice B [Invocando R], página 85).
El R el programa empieza, con una pancarta.
(Dentro de R código, el puntual en el lado de mano izquierdo no será mostrado
para evitar con- fusión.)
Ayuda.Inicio()
Inicio la interfaz de HTML a ayuda on-line (utilizando un navegador de web
disponible en vuestra máquina). Brevemente tendrías que explorar las
características de esta facilidad con el ratón.
Iconify La ventana de ayuda y movimiento encima a la parte próxima.
x <- rnorm(50)
y <- rnorm(x)
Genera dos pseudo-vectores normales aleatorios de x - y y -coordenadas.
Parcela(x, y)
Parcela los puntos en el avión. Una ventana de gráfico aparecerá automáticamente.
ls() Ve qué R los objetos son ahora en el R workspace.
rm(x, y) Saca los objetos ya no necesitaron. (Limpio arriba).
x <- 1:20 Marca x = (1, 2, . . . , 20).
w <- 1 + sqrt(x)/2
Un ‘weight' vector de desviaciones estándares.
dummy <- Datos.Marco(x=x, y= x + rnorm(x)*w)
dummy Hace un marco de dato de dos columnas, x y y, y mirada
en él.
fm <- lm(y ~ x, dato=dummy)
resumen(fm)
Cabido una regresión lineal sencilla y mirada en el análisis. Con y a la
izquierda del tilde, somos modelización y dependientes en x.
fm1 <- lm(y ~ x, dato=dummy, peso=1/w^2)
resumen(fm1)
Desde entonces sabemos las desviaciones estándares, podemos hacer un weighted
regresión.
Sujeta(dummy)
Marca las columnas en el marco de dato visible como variables.
lrf <- lowess(x, y)
Marca un nonparametric función de regresión local.
Parcela(x, y)
Parcela de punto estándar.
Líneas(x, lrf$y)
Añade en la regresión local.
abline(0, 1, lty=3)
La línea de regresión cierta: (intercepta 0, pendiente 1).
abline(coef(fm))
Unweighted Línea de regresión.
Apéndice Un: Una sesión de 83
muestra
abline(coef(fm1), col = "rojo")

Weighted Línea de regresión.
detach() Saca marco de dato de el camino de búsqueda.
Parcela(cabido(fm), resid(fm),
xlab="Cupo valores",
ylab="Residuals",
principales="Residuals vs
Cabidos")
Una parcela de diagnóstico de regresión estándar para comprobar para
heteroscedasticity. Puede lo ves?
qqnorm(resid(fm), principal="Residuals Rankit Parcela")
Una parcela de puntuaciones normal para comprobar para skewness, kurtosis
y outliers. (No muy útil aquí.)
rm(fm, fm1, lrf, x, dummy)
Limpio arriba otra vez.
La sección próxima mirará en datos de el experimento clásico de Michelson para
medir la velocidad de la luz. Este dataset es disponible en el morley objeto, pero lo
leeremos para ilustrar el leído.Función de mesa.
filepath <- Sistema.Archivo("dato", "morley.Tabulador" ,
paquete="datasets") filepath Conseguir el camino a el archivo de
dato.
Archivo.Espectáculo(filepath)
Opcional. Mirada en el archivo.
mm <- Leído.Mesa(filepath)
mm Leído en el Michelson dato como marco de datos, y mirada en él. hay cinco exper-
iments (columna Expt) y cada cual tiene 20 carreras (Carrera de columna) y
sl es la velocidad de la luz grabada, suitably coded.
mm$Expt <- Factor(mm$Expt)
mm$Corrido <-
factor(mm$Corrido)
Cambio Expt y Corrido a factores.
Sujeta(mm)
Marca el marco de dato visible en posición 3 (el default).
Parcela(Expt, Velocidad, Dato="de Velocidad de la luz principal", xlab="Núm. de
Experimento")
Comparar los cinco experimentos con sencillos boxplots.
fm <- aov(La velocidad ~ Corrida +
Expt, dato=mm) resumen(fm)
Analiza como randomized bloque, con ‘carreras' y ‘experimentos' como factores.
fm0 <- actualización(fm, . ~
. - Corrido) anova(fm0, fm)
Cabido el sub-el modelo que omite ‘carreras', y comparar utilizando un análisis formal de
varianza.
detach()
rm(fm, fm0)
Limpio arriba antes de emotivo encima.
Nosotros ahora mirada en algunos características más gráficas: contorno y parcelas de imagen.
x <- seq(-pi, pi, len=50)
y <- x x Es un vector de 50 igualmente espació valores en −π ≤ x ≤ π. y Es igual..
84
f <- Exterior(x, y, función(x, y) cos(y)/(1 + x^2))

f Es una matriz cuadrada, con filas y columnas indexed por x y y
respectivamente, de valores de la función cos(y)/(1 + x2).
oldpar <- par(Ningún.readonly =
CIERTO) par(pty="s")
Salvar el plotting parámetros y poner el plotting región para “cuadrar”.
Contorno(x, y, f)
Contorno(x, y, f, nlevels=15, añade=CIERTO)
Marca un mapa de contorno de f ; añade en más líneas para más detalle.
fa <- (f-t(f))/2
fa Es la “parte asimétrica” de f . (t() Es transpose).
Contorno(x, y, fa, nlevels=15)
Marca una parcela de contorno, . . .
par(oldpar)
. . . Y restaurar los parámetros de gráfico viejos.
Imagen(x, y, f)
Imagen(x, y, fa)
Marca algunas parcelas de imagen de densidad altas, (del cual te puede conseguir hardcopies si
deseas),
...
Objetos(); rm(x, y, f, fa)
. . . Y limpiar arriba antes de emotivo encima.
R Puede hacer aritmética compleja, también.
th <- seq(-pi, pi, len=100)
z <- exp(1i*th)
1i está utilizado para el número complejo i.
par(pty="s")
Parcela(z, tipo="l")
Plotting Los argumentos complejos significa la parcela imaginaria versus
partes reales. Esto tendría que ser un círculo .
w <- rnorm(100) + rnorm(100)*1i
Supone queremos puntos de muestra dentro del círculo de unidad. Un
método sería para tomar números complejos con estándares partes reales e
imaginarias normales . . .
w <- ifelse(Mod(w) > 1, 1/w, w)
. . . Y a mapa cualquiera fuera del círculo a su recíproco.
Parcela(w, xlim=c(-1,1), ylim=c(-1,1), pch="+",xlab="x",
ylab="y") líneas(z) Todo señala es dentro del círculo de unidad, pero la
distribución no es uniforme.
w <- sqrt(runif(100))*exp(2*pi*runif(100)*1i)
Parcela(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 tendrían que
mirar más equitativamente espaciados sobre el disco.
rm(th, w, z)
Limpio arriba otra vez.
q() Deja el R programa. Serás preguntado si quieres salvar el R workspace, y
para una sesión exploratoria así, probablemente no lo quieres salvar .
85
Apéndice B Invocando R
Usuarios de R encima Windows o macOS tendría que leer el OS-sección concreta primero,
pero orden-uso de línea es también apoyado.
B.1 Yonvoking R de la línea de orden

Cuándo working en una línea de orden en UNIX o Viento ows, la orden ‘R' lata be utilizado
both para empezar el principal R programa en la forma
R [Opciones] [<infile] [>outfile],
O, vía el R CMD interfaz, como wrapper a varios R herramientas (p. ej., para procesar
archivos en R formato de documentación o manipulando añade-en paquetes) cuáles no son
pretendidos para apellidarse “directamente”.
En la orden de Windows-línea, Rterm.exe Está preferido a R .
Necesitas asegurar que cualquiera la variable de entorno TMPDIR es unset o señala a un
sitio válido para crear directorios y archivos provisionales.
La mayoría de opciones controlan qué pasa al principio y al final de un R sesión. El
startup mechanism es tan foll ows (ve también the ayuda on-line para tema ‘Startup' para
más informa- tion, y la sección abajo para algún Windows-detalles concretos).
• A no ser que --no-environ estuvo dado, R busca usuario y archivos de sitio para procesar
para poner variables de entorno. El nombre de el archivo de sitio es el señalado a por
el environment variable R_ENVIRON; si esto es unset, R_CASA/etc/Renviron.El
sitio está utilizado (si existe). El archivo de usuario es el señalado a por la variable
de entorno R_ENVIRON_USUARIO si esto está puesto; otherwise, archivos .Renviron En
el actual o en el directorio de casa del usuario (en aquel orden) es s orejached para. Estos
files tener que contain líneas de el valor ‘de nombre=de la forma'. (Ve
ayuda("Startup") para una descripción precisa.) Variables podrías querer puesto
incluye R_ PAPERSIZE (el default medida de papel), R_PRINTCMD (el default orden de
impresión) y R_LIBS (especifica la lista de R árboles de biblioteca buscaron añadir-en
paquetes).
• Entonces R busca el sitio-ancho startup perfil a no ser que la opción de línea de la orden --
no- sitio-el archivo estuvo dado. El nombre de este archivo está tomado del valor
del R_variable de entorno del PERFIL. Si aquella variable es unset, el default
R_CASA/etc/Rprofile.El sitio está utilizado si esto existe.
• Entonces, a no ser que --no-init-el archivo estuvo dado, R busca un perfil de
usuario y fuentes él. El nombre de este archivo está tomado del entorno variable
R_USUARIO_de PERFIL; si unset, un archivo llamó .Rprofile En el directorio
actual o en el directorio de casa del usuario (en aquel orden) está buscado.
• También carga un salvado workspace de archivo .RData En el directorio actual si hay un
(a no ser que --no-restaurar o --no-restaurar-los datos estuvo
especificado).
• Finalmente, si una función .Primero() existe, está ejecutado. Esta función (así como
.Dura() cuál está ejecutado al final del R sesión) puede ser definido en el apropiado
startup perfiles, o residir en .RData.
Además, hay opciones para controlar la memoria disponible al R proceso (ve la ayuda
on-line para Memoria ‘de tema' para más información). Los usuarios no normalmente
necesitan utilizar estos a no ser que están intentando limitar la cantidad de la memoria
utilizada por R.
R Acepta la orden siguiente-opciones de línea.
--Ayuda
-h Impresión mensaje de ayuda corta a salida y producción estándares exitosamente.
--Versión
Información de versión de la impresión a salida y producción estándares exitosamente.
Apéndice B: 86
Invocando R
--Codificando=enc
Especificar el codificando para ser supuesto para entrada de la consola o stdin .
Estas necesidades de ser un codificando sabidos a iconv : ver su página de
ayuda. (--Codificando enc es también aceptó.) La entrada es re-
codificado al locale R está corriendo en y necesidades de ser representables en
el últimos está codificando (así que p. ej. puedes no re-codificar texto griego en
un francés locale a no ser que aquel locale utiliza el UTF-8 codificando).
RHOME Imprime el camino al R “directorio de casa” a salida y producción estándares
éxito- plenamente. Aparte del frente-guión de concha del fin y la página de
hombre, R la instalación pone todo (executables, paquetes, etc.) a este directorio.
--Salvar
--No-salvar
Control si conjuntos de dato tendrían que ser salvados o no al final del R
sesión. Si tampoco está dado en una sesión interactiva, el usuario está pedido
el comportamiento deseado cuándo acabando la sesión con q() ; en uso no
interactivo uno de este mosto ser especificado o implicado por algunos otra
opción (ve abajo).
--No-environ
No lee cualquier archivo de usuario para poner variables de entorno.
--No-sitio-archivo
No lee el sitio-perfil ancho en startup.
--No-init-archivo
No lee el perfil del usuario en startup.
--Restaurar
--No-restaurar
--No-restaurar-datos
Control si salvó imágenes (archivo .RData En el directorio donde R estuvo
empezado) tendría que ser restaurado en startup o no. El default es para restaurar.
(--No-restaurar implica todo el concreto --no-restaurar-* opciones.)
--No-restaurar-historia
Control si el archivo de historia (normalmente archivo .Rhistory En el
directorio donde R estuvo empezado, pero puede ser puesto por la variable de
entorno R_HISTFILE) tendría que ser restaurado en startup o no. El default es
para restaurar.
--No-Rconsole
(Windows único) Impide cargar el Rconsole archivo en startup.
--
Vainilla Combina --no-salvar, --no-environ, --no-sitio-archivo, --no-init-archivo y --no-
restaurar. Debajo Windows, esto también incluye --no-Rconsole.
-f
Archivo
--Archivo=de archivo
(No Rgui.exe) TUnke entrada from file: ‘-' medio stdin. Implica --no-salvar a no ser que
--Salva ha sido puesto. En un Unix-parecido, concha metacharacters tendría que ser
evitado en
Archivo (pero los espacios están dejados).
-e Expresión
(No Rgui.exe) Expresión de uso como una línea de entrada. Uno o más -e las
opciones pueden ser utilizadas, pero no junto con -f o --archivo . Implica --no-
salvar a no ser que --salva ha sido puesto. ( Hay un límite de 10,000 bytes en
la longitud total de expresiones utilizó de este modo. Las expresiones que
contienen espacios o concha metacharacters necesitará ser citado.)
Apéndice B: 87
Invocando R
--No-readline
(UNIX único) Apaga orden-tacha editar vía readline. Esto es útil cuándo corrido-
ning R de dentro de Emacs utilizando el ESS (“Emacs Habla Estadística”)
paquete. Ve Apéndice C [La orden-editor de línea], página 92, para más
información. Orden- tacha editar está habilitado para default uso interactivo (ve --
interactivo). Esta opción también afecta tilde-expansión: ver la ayuda para
camino.Expande.
--min-vsize=N
--min-nsize=N
Para uso experto sólo: puesto las medidas de gatillo iniciales para colección de basura
de vector heap (en b ytes) y c ons cells (number) respectively. Sufijo ‘M'
specifies megabytes o millones de células respectivamente. El defaults es 6Mb y
350k respectivamente y también puede ser puesto por variables de entorno
R_NSIZE y R_VSIZE .
--max-ppsize=N
Especificar la medida máxima de la protección de puntero stack como N
ubicaciones. Este defaults a 10000, pero puede ser aumentado para dejar
grande y complicó cálculos para ser hechos. Actualmente el valor máximo
aceptó es 100000.
--max-mem-Medida=N
(Windows único) Especifica un límite para la cantidad de memoria para ser
utilizada ambos para R objetos y áreas laborables. Esto está puesto por
default al más pequeño de la cantidad de RAM física en la máquina y para
32-mordió R, 1.5Gb1, y tiene que ser entre 32Mb y el máximo dejado en
aquella versión de Windows..
--Tranquilo
--Silencioso
-q No imprime fuera de el copyright inicial y mensajes bienvenidos.
--Marca de esclavo R correr tan tranquilamente tan posible. Esta opción está pretendida
para apoyar programas qué uso R para computar resultados para ellos. Implica --
tranquilo y --no-salvar .
--Interactivo
(UNIX único) Afirma que R realmente está siendo corrido interactivamente incluso
si la entrada ha sido redirigida: uso si la entrada es de un FIFO o tubo y alimentado
de un programa interactivo. (El default es para deducir que R está siendo corrido
interactivamente si y sólo si stdin está conectado a un terminal o pty .) Utilizando
-e, -f o --el archivo afirma uso no interactivo incluso si --interactivo
está dado.
Nota que esto no gira encima orden-tacha editar.
--ess (Windows único) Puso Rterm arriba para uso por R-inferior-modo en ESS ,
incluyendo afirma- ing uso interactivo (sin la orden-editor de línea) y ningún
buffering de stdout .
--Verboso
Impresión más información aproximadamente progreso, y en particular puesto R la opción
verbosa a
CIERTO. R El código utiliza esta opción para controlar la impresión de mensajes de
diagnóstico.
--Nombre=de depurador
-d Nombre (UNIX único) Corrido R a través de nombre de depurador. Para más depuradores
(las excepciones son valgrind y versiones recientes de gdb ), opciones de línea
de orden más lejanas están desatendidas, y en cambio tendría que ser dado cuándo
empezando el R ejecutable de dentro del depurador.
--gui=Tipo
-Tipo de g (UNIX único) tipo de Uso como interfaz de usuario gráfico (nota que esto
también incluye en- teractive gráfico). Currently, possible values para t ype es
‘X11' (el default) y,
Apéndice B: 88
Invocando R
1
2.5Gb en versiones de Windows aquel soporte 3Gb por proceso y tener el soporte habilitó: ver el rw-FAQ
Q2.9; 3.5Gb encima la mayoría de 64-mordió versiones de Windows.
Apéndice B: 89
Invocando R
provided Que ‘Tcl/Tk' support es un vailable, ‘Tk'. (FO ba ck-compatibility, ‘x11'

unnd ‘tk' está aceptado.)
--Nombre=de arco
(UNIX único) Corrido el especificado sub-arquitectura.
--args Esta bandera nada exceptúa causa el resto de la línea de orden para ser skipped:
esto puede ser útil de recuperar valores de él con commandArgs(CIERTO) .
Nota que la entrada y la producción pueden be redirigidos en el habituales wuny
(utilizando ‘<' y ‘ >'), but el límite de longitud de la línea de 4095 bytes todavía aplica. Aviso y
mensajes de error están enviados al canal de error (stderr).
La orden R CMD deja la invocación de varias herramientas qué es útil conjuntamente con
R, pero no pretendido para apellidarse “directamente”. La forma general es
R CMD orden args
Dónde la orden es el nombre de la herramienta y args los argumentos pasaron encima a él.
Actualmente, las herramientas siguientes son disponibles.
Carrera de LOTE R en modo de lote. Carreras R --restaurar --salvar con posiblemente opciones
más lejanas (ve
?LOTE).
COMPILA (UNIX único) Compila C, C++, Fortran . . . Archivos para uso con R..
SHLIB Complexión biblioteca compartida para dinámico cargando.
INSTALAR Instalar añadir-en paquetes.
SACAR Sacar añadir-en paquetes.
Complexión de complexión (aquello es, paquete) añade-en paquetes.
Control de control añade-en paquetes.
ENLACE (UNIX único) Frente-fin para crear programas ejecutables.
Rprof Correo-proceso R profiling archivos.
Rdconv
Rd2txt Convert Rd formato a v arious otros formatos, incluyendo HTML, LUnT EX,
texto sencillo, y extrayendo los ejemplos. Rd2txt puede ser utilizado tan
taquigrafía para Rd2conv -t txt.
Rd2pdf Convierte Rd formato a PDF..
Stangle Extracto S/R código de Sweave u otro vignette documentación
Sweave Proceso Sweave u otro vignette documentación
Rdiff Diff R La producción que ignora
encabezamientos etc config Obtener
información de configuración javareconf
(Unix único) Actualiza el Java variables de configuración
rtags (Unix único) Crea Emacs-archivos de etiqueta del estilo de C, R,
y Rd los archivos abren (Windows único) Abre un archivo vía
Windows' asociaciones de archivo texify (Windows único) Proceso
(La)TeX archivos con R archivos de estilo
Uso
R CMD orden --ayuda
Para obtener información de uso para cada de las herramientas accesibles vía el R CMD interfaz.
Apéndice B: 90
Invocando R
Además, puedes utilizar opciones --arco=, --no-environ, --no-init-archivo, --

no-sitio- archivo y --vainilla entre R y CMD : estos afectan cualquier R los procesos
corridos por las herramientas. (Aquí
--La vainilla es equivalente a --no-environ --no-sitio-archivo --no-init-archivo.)
Aun así, nota que R CMD no de él utiliza cualquier R startup archivos (en particular, ni usuario
ni sitio Renviron archivos), y todo del R los procesos corridos por estas herramientas
(exceptúa LOTE) uso --no-restaurar. La mayoría de uso --vainilla y así que invoca
no R startup archivos: las excepciones actuales son INSTALA, SACA, Sweave y SHLIB (cuál
utiliza --no-sitio-archivo --no-init-archivo).
R CMD cmd args
Para cualquier otro ejecutable cmd en el camino o dado por un absoluto filepath: esto es útil
de tener el mismo entorno como R o las órdenes concretas corridas debajo, por ejemplo para
correr ldd o pdflatex . Debajo Windows cmd puede ser un ejecutable o un archivo de lote, o
si tiene extensión .sh O .pl El intérprete apropiado (si disponible) se apellida para
correrlo.
B.2 Yonvoking R debajo Windows

Hay dos maneras para correr R debajo Windows. Dentro de una ventana terminal (p. ej.
cmd.exe O una concha más capaz), los métodos describieron en la sección anterior puede
ser utilizada, invocando por R.exe O más directamente por Rterm.exe. Para uso
interactivo, hay una consola-basado GUI (Rgui.exe).
El startup procedimiento debajo Windows es muy similar a aquel debajo UNIX, pero
referencias al ‘directorio de casa' necesidad de ser aclarada, cuando esto no es siempre
definido encima Windows. Si el entorno variable R_el USUARIO está definido, aquello
da el directorio de casa. Luego, si el entorno la CASA variable está definida, aquello da
el directorio de casa. Después de aquel dos usuario-encuadres controlables, R intenta
encontrar sistema directorios de casa definida. Primero intenta utilizar el Windows
"directorio" personal (típicamente Mis Documentos en versiones recientes de
Windows). Si aquello falla, y variables de entorno HOMEDRIVE y HOMEPATH está
definido (y normalmente son) estos definen el directorio de casa. Fallando todo aquellos,
el directorio de casa está tomado para ser el directorio de empezar..
Necesitas asegurar que cualquiera las variables de entorno TMPDIR, TMP y TEMP es
cualquier unset o uno de ellos puntos a un sitio válido para crear directorios y archivos
provisionales.
Environment variables Puede be suministrado como ‘name=valor' pares en la orden line.
Si hay un final de argumento .RData (De todas formas) está interpretado como el
camino al workspace para ser restaurado: implica --restaurar y pone el directorio
laborable a el padre del archivo nombrado. (Este mecanismo está utilizado para arrastrar-
y-gota y asociación de archivo con RGui.exe , pero también trabajos para Rterm.exe. Si
el archivo nombrado no existe pone el directorio laborable si el directorio de padre
existe.)
La orden adicional siguiente-opciones de línea son disponibles cuándo invocando RGui.exe.
--mdi
--sdi
--No-mdi Control si Rgui operará como un MDI programa (con ventanas de niño múltiple
dentro uno ventana principal) o un SDI aplicación (con ventanas de nivel superior
múltiples para la consola, gráfico y pager). La orden-tacha poner overrides el
encuadre en el usuario Rconsole archivo.
--Depurar Habilitar la “Rotura a elemento” de carta del depurador en Rgui, y provocar una
rotura al depurador durante procesamiento de línea de la orden.
Debajo Windows con R CMD te también puede especificar vuestro propio .Murciélago,
.exe, .sh O .pl Archivo. Sea corrido bajo el intérprete apropiado (Perl para .pl) Con
varias variables de entorno puestas apropiadamente, incluyendo R_CASA, R_OSTYPE, CAMINO,
BSTINPUTS y TEXINPUTS . Por ejemplo, si ya tienes látex.exe En vuestro camino, entonces
R CMD látex.exe mydoc
Apéndice B: 91
Invocando R
run LUnT EX en mydoc.tex, con el camino a R participación/texmf macros appacabó a

TEXINPUTS . (Unfortunately, este does no ayudar con el MiKTcomplexión ex de LUnT
EX, pero R CMD texify mydoc trabajará en aquel caso.)
B.3 Yonvoking R bajo macOS

Hay dos maneras para correr R bajo macOS. Dentro de una Terminal.Ventana de
aplicación por invocar R, los métodos describieron en el primer inciso aplica. hay también
consola-basado GUI (R.Aplicación) que por default está instalado en la carpeta de
Aplicaciones en vuestro sistema. Es un estándar doble-clickable macOS aplicación.
El startup procedimiento bajo macOS es muy similar a aquel debajo UNIX, pero R.La
aplicación no hace uso de orden-argumentos de línea. El ‘directorio de casa' es el dentro
del R.Marco, pero el startup y el directorio laborable actual está puesto como el directorio de
casa del usuario a no ser que un diferente startup el directorio está dado en la ventana de
Preferencias accesible de dentro del GUI.
B.4 Scripting Con R.

Si justo quieres correr un archivo foo.R De R órdenes, la manera recomendable es para
utilizar R CMD LOTE foo.R. Si quieres correr esto en el de fondo o como uso de trabajo
del lote OS-instalaciones concretas para hacer tan: por ejemplo en más conchas encima
Unix-parecido OSes R CMD LOTE foo.R & Corre un trabajo de fondo.
Puedes pasar parámetros a guiones vía argumentos adicionales en la línea de orden:
por ejemplo (dónde el exacto citando necesitado dependerá de la concha en uso)
R CMD LOTE "--args arg1 arg2" foo.R &
Pasará argumentos a un guión cuáles pueden ser recuperados como vector de carácter por
args <- commandArgs(CIERTO)
Esto está hecho más sencillo por el frente alternativo-fin Rscript, los cuales pueden ser invocados por
Rscript foo.R arg1 arg2
Y esto también puede soler escribir a archivos de guión ejecutable les gusta (al menos
encima Unix-alikes, y en algunas conchas de Windows)
#! /Camino/a/Rscript
args <- commandArgs(CIERTO)
...
q(Código=<de estado de salida de estado>)
Si esto está introducido a un archivo de texto runfoo y esto está hecho ejecutable (por chmod
755 runfoo), pueda ser invocado para argumentos diferentes por
runfoo arg1 arg2
Para las opciones más lejanas ven ayuda("Rscript"). Esto escribe R producción a stdout y
stderr , y esto puede ser redirigido en la manera habitual para la concha que corre la orden.
Si no deseas a hardcode el camino a Rscript pero tener él en vuestro camino (cuál es
normalmente el caso para un instalado R exceptúa encima Windows, pero p. ej. macOS los
usuarios pueden necesitar añadir
/usr/Cubo/local a su camino), uso
#! /usr/Cubo/env Rscript
...
Al menos en Bourne y bash conchas, el #! El mecanismo no deja a argumentos extras les gusta #!
/usr/Cubo/env Rscript --vainilla.
Una cosa para considerar es lo que stdin() refiere a. Es tópico para escribir R los
guiones con segmentos gustan
chem <- Escáner(n=24)
91
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() refiere al archivo de guión para dejar tal uso tradicional. Si quieres referir al proceso
stdin, uso "stdin" como conexión de archivo, p. ej. escáner("stdin", ...).
Otro wuny para escribir archivos de guión ejecutable (suggested by Fcorrióçois Pinard)
es para utilizar un élre a documento le gusta
#!/Cubo/sh
[Variables de entorno pueden ser
puestas aquí] R --esclavo [otras
opciones] <<EOF
R El programa va aquí...
EOF
Pero aquí stdin() refiere a la fuente de programa y stdin "" no será utilizable.
Los guiones cortos pueden ser pasados a Rscript en la orden-línea vía el -e bandera. (Los
guiones vacíos no son aceptados.)
Nota que en un Unix-parecido la entrada filename (como foo.R) No tendría que
contener espacios ni concha metacharacters.
92
Apéndice C La orden-editor de línea
C.1 Preliminaries
Cuándo el GNU readline la biblioteca es disponible en el tiempo R está configurado para
recopilación un- der UNIX, un inbuilt editor de línea de la orden que deja recuerda,
editando y re-la sumisión de órdenes previas está utilizada. Nota que otras versiones de
readline existir y puede ser utilizado por el inbuilt editor de línea de la orden: esto utilizó
para pasar en macOS.
Pueda ser inutilizado (útil para uso con ESS 1) utilizando el startup opción --no-readline.
Vientoows versions de R hunve un poco más sencillo comhombred-line editando: ve
‘Console' bajo la ‘Ayuda' menu de el GUyo, y el archivo README.Rterm Para orden-tacha editar
bajo Rterm.exe.
Cuándo utilizando R con GNU 2 readline capacidades, las funciones describieron abajo es
disponible, así como otros (probablemente) documentó en hombre readline o info
readline en vuestro sistema.
Muchos de este uso cualquier Control o Meta caracteres. Caracteres de control, como
Control-m, está obtenido por aguantar el CTRL abajo mientras pulsas el m llave, y está
escrito cuando C-m abajo. Meta Caracteres, como Meta-b, está escrito por aguantar abajo
META3 y prensado b, y escrito cuando M-b en el siguiente. Si vuestra terminal no tiene un
META la llave habilitó, todavía puedes escribir Meta los caracteres que utilizan secuencias
de dos caracteres que empiezan con ESC . Así, para introducir M-b, podrías escribir ESCb.
El ESC secuencias de carácter son también dejadas en terminales con reales Meta llaves.
Nota que el caso es significativo para Meta caracteres.
Algunos pero no todas las versiones 4 de readline reconocerá resizing de la ventana
terminal tan esto es más evitó.
C.2 Editando acciones

El R el programa mantiene una historia de la orden te tachas tipo, incluyendo las líneas
erróneas, y las órdenes en vuestra historia pueden ser recordadas, cambió si es necesario, y
re-entregado como órdenes nuevas. En Emacs-orden de estilo-tacha editar cualquier recto
escribiendo haces mientras en esta fase de editar causa los caracteres para ser insertados
en la orden estás editando, desplazando cualesquier caracteres a la derecha del cursor. En
vi modo de inserción de carácter de modo está empezado por M-i o M-un , los caracteres
están escritos y modo de inserción está acabado por escribir un más lejano ESC. (El default
es Emacs-estilo, y sólo aquello está descrito aquí: para vi el modo ve el readline
documentación.)
Pulsando el RET la orden en cualquier tiempo causa la orden para ser re-
entregó. Otras acciones de editar son summarized en la mesa siguiente.
C.3 Orden-resumen de editor de la línea

La orden recuerda y movimiento vertical
C-p Va a la orden anterior (atrás en la historia).
C-n Va a la orden próxima (delanteros en la historia).
C-r El texto Encuentra la última orden con la cuerda de texto en él. Esto puede ser
cancelado por C-g (y encima algunas versiones de R por C-c).
1
El ‘Emacs Habla Estadística' paquete; ver el URL https://ess.r-project.org/
2
Es posible de construir R utilizando una emulación de GNU readline, como uno basado en NetBSD
editline, lo qué caso sólo un subconjunto de las capacidades puede ser proporcionado.
3
En un teclado de PC esto es normalmente el Alt llave, ocasionalmente el ‘Windows' llave. En un Mac
teclado normalmente ningún meta la llave es disponible.
4
En particular, no versiones 6.3 o más tarde: esto está trabajado alrededor tan de R 3.4.0.
Apéndice C: La orden-editor de 93
línea
Encima más terminales, también puedes utilizar el arriba y abajo llaves de flecha en vez
de C-p y C-n , respectivamente.
Movimiento horizontal del cursor

C-un Ir al principio de la orden.
C-e Va hasta el final de la línea.
M-b Vuelve una palabra.
M-f Va de frente una palabra.
C-b Vuelve un carácter.
C-f Va de frente un carácter.
Encima más terminales, también puedes utilizar la flecha izquierda y correcta llaves en
vez de C-b y C-f , respectivamente.
Editando y re-sumisión
El texto Inserta texto en el cursor.
C-f el texto Anexa texto después del cursor.
DEL Elimina el carácter anterior (dejado del cursor).
C-d Eliminar el carácter bajo el cursor.
M-d Eliminar el resto de la palabra bajo el cursor, y “salvarlo..
C-k Elimina de cursor para acabar de orden, y “salvarlo..
C-y Inserta (yank) el último “texto” salvado aquí.
C-t Transpose el carácter bajo el cursor con el próximo.
M-l Cambio el resto de la palabra para bajar
caso. M-c Cambio el resto de la palabra a caso
superior. RET Re-Entregar la orden a R.
El final RET rescinde la línea de orden que edita secuencia.
El readline las encuadernaciones claves pueden ser personalizadas en la manera habitual vía
un ~/.inputrc Archivo. Estos customizations puede ser condicionado encima aplicación R,
aquello es por incluir a una sección le gusta
$Si R
"\C-xd": "q('ningún')\n"
$endif
94
Apéndice D Función y índice variable
! ?
!.................................................. 9 ?.................................................. 4
!= . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9 ?? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
% ^
* . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
^.................................................. 8
o .......................................................................... 21
& |
|.................................................. 9
&.................................................. 9 || . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
&& . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
* ~
*.................................................. 8 ~ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
+ Un
+.................................................. 8 abline ................................................................ 66
As ........................................................................ 61
– Añade1 ..................................................................... 56
anova ................................................................. 54, 55
-.................................................. 8 aov............................................................................ 55
aperm ....................................................................... 21
. Variedad ........................................................... 20
Cuando.Dato.Marco ......................................... 27
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
Cuando.Vector ................................................. 24
.Primer .................................................... 48
Sujeta ................................................................ 28
.Último .......................................................... 48
attr ...................................................... 14
Atributos ....................................................... 14
/ avas...................................................................... 61
/.................................................. 8 Axial ................................................................. 67
: B
:.................................................. 8 boxplot ................................................................ 37
:: . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78 Rotura .................................................................. 41
::: . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78 bruto ................................................................. 61
<
<.................................................. 9
C
<<- . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47 c ................................................................7, 10, 24, 27
<= . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9 cbind .................................................................... 24
coef ...................................................................... 54
Coeficientes .................................................. 54
= Contorno ............................................................. 65
== . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9 Contrastes ..................................................... 53
coplot ................................................................ 64
> cos ..........................................................................8
crossprod ........................................................ 19, 22
>.................................................. 9 Corte ................................................................. 25
>= . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9 C ........................................................................................ 53
Apéndice D: Función y índice variable 95
D K
Dato.................................................................. 31 ks.Prueba .....................................................36
Dato.Marco ...................................................... 27
Densidad .......................................................... 34 L
det .................................................................... 23
detach................................................................... 28 Leyenda ................................................................ 66
Determinante ................................................... 23 Longitud ........................................................... 8, 13
dev.Lista..................................................... 75 Niveles ........................................................... 16
dev.Luego ............................................................ 75 Líneas ............................................................. 66
dev.Fuera ......................................................... 75 Lista ............................................... 26
dev.prev ............................................................... 75 lm ...................................................................................... 54
dev.Conjunto ................................................... 75 lme ........................................................................... 61
deviance ............................................................... 54 locator ................................................................68
diag ...................................................................... 22 loess ...................................................................61
dim ........................................................................... 18 Registro .................................................................. 8
dotchart ............................................................ 65 lqs ................................................................... 61
Gota1 ....................................................................... 56 lsfit ................................................... 23
E M
ecdf ...................................................................... 35 mars.......................................................................... 61
Edita .............................................................. 32 max ..................................................................................... 8
eigen .................................................................... 23 Malo .................................................................................... 8
Más................................................................ 40 Métodos ................................................................... 49
Error ................................................................. 55 min ............................................................................. 8
Ejemplo ...................................................................... 4 Modo ................................................................................ 13
exp ............................................................................. 8
N
F NaN ..................................................................................... 9
NA ....................................................................................... 9
Factor ............................................................ 16 ncol ....................................................................... 22
FALSO ............................................................................... 9 Luego ................................................................... 41
fivenum ................................................................... 34 nlm ................................................................ 59, 60, 61
Para ............................................................... 40 nlme ......................................................................... 61
Fórmula ............................................................... 54 nlminb ...................................................................... 59
Función ............................................................ 42
nrow ......................................................................... 22
F .......................................................................................... 9
O
G
optim ........................................................................ 59
getAnywhere ............................................................ 49 Orden .................................................................. 8
Consigue3método ................................................... 49 Ordenado .............................................................. 17
glm ........................................................................... 57 Exterior..............................................................21
H P
Ayuda .................................................................... 4 Pares ............................................................... 64
Ayuda.Búsqueda ............................................... 4 par......................................................................... 68
Ayuda.Inicio ................................................ 4 Pasta ..................................................................10
hist .......................................................... 34, 64 Pdf ........................................................................ 74
persp ..................................................................... 65
Parcela ......................................................... 54, 63
Yo pmax ................................................................................... 8
Identifica ....................................................... 68 pmin ........................................................................... 8
Si ................................................... 40 png ........................................................................... 74
ifelse ........................................................... 40 Puntos ................................................................66
Imagen ..................................................................... 65 Polígono .................................................................. 66
is.na ................................................................. 9 Posdata ........................................................... 74
Es.nan............................................................ 10 Pronostica ..........................................................54
Impresión ....................................................... 54
prod ........................................................................ 8
J
jpeg ..................................................................... 74
Apéndice D: Función y índice variable 96
Q Resumen............................................................. 34, 54
qqline .............................................................. 35, 64 svd............................................................................ 23
qqnorm ................................................................ 35, 64
qqplot ................................................................... 64 T
qr .......................................................................... 23
t ................................................. 21
Cuarzo .............................................................. 74
t.Prueba ........................................... 37
Mesa ............................................................ 20, 25
R Bronceado .......................................................... 8
tapply .................................................................16
Gama ..................................................................... 8 Texto ............................................................. 66
rbind ................................................................. 24 Título .............................................. 67
Leído.Mesa ................................................... 30 Árbol .............................................................. 62
rep .......................................................................... 9 T .......................................................................................... 9
Repite ............................................................... 41 CIERTO .............................................................................. 9
resid ............................................................... 54
residuals ........................................................ 54
rlm ........................................................................... 61 U
rm ....................................................................................... 6 unclass .............................................................. 14
Actualización ...................................................... 55
S
Escáner ................................................................ 31
V
sd ............................................................................. 17 var..................................................................... 8, 17
Búsqueda ............................................................. 29 var.Prueba ...................................................38
seq .......................................................................... 8 vcov.......................................................................... 55
shapiro.Prueba .............................................. 36 Vector ................................................................. 7
Pecado ............................................................. 8
Fregadero ........................................................... 5 W
Soluciona ......................................................... 22
Clase ............................................................... 8 Mientras .............................................................. 41
Fuente ................................................................ 5 wilcox.Prueba ................................................ 38
Ruptura ................................................. 40 Ventanas ................................................................... 74
sqrt .................................................................. 8
Raíz ......................................................................... 34 X
Paso................................................................. 54, 56 X11 ................................................................................... 74
Suma................................................................................... 8
97
Apéndice E índice de Concepto
Un K
Accediendo builtin datasets ................................ 31 Kolmogorov-Smirnov Prueba ................................ 36
Modelos aditivos .................................................... 61
Análisis de varianza .............................................. 55
Funciones de aritmética y operadores ................. 7 L
Variedades .............................................................. 18 Menos cuadra caber................................................ 23
Asignación ................................................................ 7 Ecuaciones lineales ................................................. 22
Atributos .............................................................. 13 Modelos lineales ..................................................... 54
Listas ....................................................................... 26
B Local aproximando regresiones ............................. 61
Bucles y ejecución condicional ............................ 40
Operadores binarios ................................................ 43
Parcelas de caja ....................................................... 37
M
C Matrices ................................................................... 18
Multiplicación matricial ......................................... 22
Vectores de carácter ............................................ 10
Máximo likelihood .................................................. 61
Clases .................................................................. 14, 48
Valores desaparecidos ................................................ 9
Concatenando listas ................................................ 27
Modelos mixtos ....................................................... 61
Contrastes ............................................................ 53
Declaraciones de control..................................... 40
CRAN...................................................................... 77 N
Personalizando el entorno ...................................... 48
Nombró argumentos ............................................... 43
Namespace ............................................................... 78
D Nonlinear Menos cuadra ........................................ 59
El dato enmarca ...................................................... 27
Default Valora ............................................................ 43
Valoración de densidad .......................................... 34 O
Determinantes ......................................................... 23 Orientación de objeto .......................................... 48
Desviando entrada y producción ......................... 5 Objetos .................................................................... 13
Gráfico dinámico .................................................... 76 Uno- y dos-la muestra prueba ............................... 36
Ordenó factores ................................................. 16, 53
Productos exteriores de variedades .................... 21
E
Eigenvalues Y eigenvectors .................................. 23
Empírico CDFs ....................................................... 35 P
Paquetes .................................................................. 2, 77
Distribuciones de probabilidad ........................... 33
F
Factores ................................................................. 16, 53
Familias ................................................................... 57 Q
Formulae ..................................................................... 51 QR Descomposición ............................................... 23
Quantile-quantile Parcelas ..................................... 35
G
Modelos lineales generalizados ............................. 56 R
Generalizado transpose de una variedad .............. 21
Funciones genéricas ............................................... 48 Leyendo dato de archivos ..................................... 30
Conductores de dispositivo del gráfico ................. 74 Reciclando regla ................................................. 7, 20
Parámetros de gráfico ......................................... 68 Secuencias regulares ................................................. 8
Agrupó expresiones ................................................ 40 Sacando objetos ........................................................ 6
Regresión robusta ................................................... 61
Yo
Indexación de y por variedades ............................. 18
Vectores de indexación .......................................... 10
Apéndice E: índice de 98
Concepto
S U
Alcance .................................................................... 46 Actualizando cupo modelos ................................ 55
Camino de búsqueda .............................................. 29
Shapiro-Wilk Prueba .............................................. 36
Descomposición de valor singular ......................... 23
V
Modelos estadísticos .............................................. 51 Vectores .........................................................................7
Estudiantil t prueba ................................................. 37
W
Wilcoxon Prueba ................................................... 38
T Workspace.................................................................. 5
Tabulación ........................................................... 25 Escribiendo funciones ............................................. 42
Árbol-basó modelos ............................................... 62
99
Apéndice F Referencias
D. M. Bates Y D. G. Vatios (1988), Nonlinear Análisis de Regresión y Sus Aplicaciones. John
Wiley & Hijos, Nueva York.
Richard Un. Becker, John M. Cuartos y Allan R. Wilks (1988), El Nuevo S Lengua. Chap- Sala
& de hombre, Nueva York. Este libro es a menudo llamó el “Libro Azul ”.
John M. Cuartos y Trevor J. Hastie eds. (1992), Modelos Estadísticos en S. Chapman &
Sala, Nueva York. Esto es también llamó el “Libro Blanco ”.
John M. Cuartos (1998) Programación con Datos. Salmer, Nueva York. Esto es también
llamó el “Green Bo vale ”.
Un. C. Davison Y D. V. Hinkley (1997), Bootstrap Métodos y Sus Aplicaciones, Cambridge
Prensa Universitaria.
Annette J. Dobson (1990), Una Introducción a Modelos Lineales Generalizados,
Chapman y Sala, Londres.
Peter McCullagh y John Un. Nelder (1989), Modelos Lineales Generalizados. Segunda
edición, Chap- hombre y Sala, Londres.
John Un. Arroz (1995), Dato y Estadística Matemáticos Análisis. Segunda edición. Duxbury
Prensa, Belmont, CA.
S. D. Silvey (1970), Inferencia Estadística. Pingüino, Londres.

Una Introduccion 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 Introduccion A R

Cargado por

Copyright:

Formatos disponibles

Una Introducción a R.

Notas en R: Un Entorno de Programación para Análisis de Datos y Gráfico.

1 Introducción y preliminaries ...................................................... 2

2 Manipulaciones sencillas; números y vectores ........................ 7

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

4 Ordenado y unordered factores ............................................... 16

5 Variedades y matrices ............................................................... 18

6 Las listas y el dato enmarca ...................................................... 26

7 Leyendo dato de archivos ......................................................... 30

8 Distribuciones de probabilidad ................................................ 33

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

10 Escribiendo vuestras funciones propias ................................. 42

11 Modelos estadísticos en .......................................................... R 51

12 Procedimientos gráficos ........................................................... 63

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

Apéndice C La orden-editor de línea ........................................ 92

Apéndice D Función y índice variable ...................................... 94

Apéndice E índice de Concepto................................................... 97

Apéndice F Referencias ................................................................ 99

1.1 TÉl R entorno

1.2 Related Software y documentación.

1.4 R Y el sistema de ventana

1.5 Utilizando R interactivamente

1.6 Unn sesión introductoria

1.7 Consiguiendo ayuda con funciones y características.

1.8 R Órdenes, sensibilidad de caso, etc.

1.9 Recall Y corrección de órdenes anteriores

1.10 Executing Órdenes de o desviando producción a un archivo

1.11 Dato permanency y sacando objetos

Para sacar objetos la función rm es disponible:

2 Manipulaciones sencillas; números y vectores.

2.1 Vectors y asignación.

2.2 Vector aritmética

Los operadores de aritmética elementales son el habituales +, -, *, / y ^ para levantar a un

2.3 Generando secuencias regulares

Genera el mismo vector en s4.

2.4 Logical vectores

2.5 Missing Valores

2.6 Character Vectores

2.7 Yondex vectores; seleccionando y modificando subconjuntos de un

2. Un vector de cantidades integrales positivas. En este caso los valores en la mentira de

2.8 Other Tipos de objetos.

Ambas variables numéricas y categóricas. Muchos experimentos son más descritos

3 Objects, sus modos y atributos.

3.1 Yontrinsic atributos: modo y longitud.

3.2 Cambiando la longitud de un objeto

3.3 Consiguiendo y poniendo atributos

3.4 TÉl clase de un objeto

4 Ordenado y unordered factores

4.1 Un ejemplo concreto

4.2 La función tapply() y ragged variedades

Como si eran estructuras de vector separado . El resultado es una estructura de la misma

4.3 O rdered Factores

5.2 Unrray indexación. Incisos de una variedad

5.3 Matrices de índice

5.4 La variedad() función

5.4.1 Mixed vector y aritmética de variedad. La regla de reciclaje

5.5 TÉl producto exterior de dos variedades

Un ejemplo: Determinantes de 2 por 2 matrices de dígito solo

5.6 Generalizado transpose de una variedad

5.7 Matrix instalaciones

5.7.1 Materix multiplicación

5.7.2 Ecuaciones lineales e inversion