Uma Introdução Ao R (PT-BR)

Uma Introdução ao R
Notas sobre R: um ambiente de programação para análise de dados e gráficos

Versão 3.5.1 (2018-07-02)
WN Venables, DM Smith ea R Core Team

Este manual é para R, versão 3.5.1 (2018/07/02). copyright c
© 1990 WN Venables de
Copyright c © 1992 WN Venables & DM Smith de Copyright c
© 1997 R. Gentleman & R. Ihaka de Copyright
c © 1997, 1998 M. Maechler
copyright c © 1999-2018 R Core Team
É dada permissão para fazer e distribuir cópias deste manual desde o aviso de copyright e este aviso de
permissão sejam preservados em todas as cópias. É concedida permissão para copiar e distribuir versões
modificadas deste manual sob as condições da cópia literal, desde que todo o trabalho derivado resultante é
distribuído sob os termos de um aviso de permissão idêntica a esta. É concedida permissão para copiar e
distribuir traduções deste manual para outro idioma, sob as condições acima para versões modificadas, exceto
que este aviso de permissão pode ser afirmado em uma tradução aprovada pela Core Team R.
Eu
Índice
Prefácio. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
1 Introdução e preliminares. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.1 O ambiente de R. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.2 relacionadas software e documentação. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.3 R e estatísticas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
1,4 o sistema de janelas e R. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.5 Uso R interactivamente. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.6 Uma sessão introdutória. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
1.7
1 7 Ob
Obter
e aajuda
uda com as funções
unções e ca
características.
ac e s cas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
1 8 comandos R sens b dade caso e c 4
1 9 Reca e co eção dos comandos an e o es 5
1 10 A execução de comandos a pa de ou desv a sa da pa a um a qu vo 5
1 11 pe manênc a de dados e ob e os de emoção 5
2 man pu ações s mp es; números e vectores. . . . . . . . . . . . . . . . . 7

2 1 Ve o es e a bu ção 7
2 2 Vec o a mé ca 7
2 3 Ge ação de sequênc as egu a men e 8
2 4 vec o es óg co 9
2 5 va o es que a am 9
2 6 ve o es de ca ac e es 10
2 7 vec o es de nd ce se ecc ona e mod ca subcon un os de um con un o de dados 10
2 8 Ou os pos de ob ec os 11
3 ob etos, seus modos e atr butos. . . . . . . . . . . . . . . . . . . . . . . . . 13

3 1 a bu os n nsecos o modo e comp men o 13
3 2 A a e ação do comp men o de um ob ec o 14
3 3 Ob endo e de n a bu os 14
3 4 A c asse de um ob ec o 14
4 ordenadas e não ordenadas factores. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16

4 1 Um exemp o espec co 16
4 2 A unção app y e ma zes egu a 16
4 3 ac o es o denada 17
5 matr zes e matr zes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18

5 1 A ays 18
5 2 ndexação Ma z Subsecções de uma ma z 18
5 3 ma zes nd ce 19
5 4 O ma z unção 20
5 4 1 m s u ada vec o e de ma z a mé ca A eg a ec c agem 20
5 5 O p odu o ex e no de duas ma zes 21
5 6 anspos a gene a zada de uma ma z 21
5 7 ns a ações ma z 22
5 7 1 A mu p cação de ma zes 22
ii
5.7.2 equações lineares e inversão. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22

5.7.3 Valores e vectores próprios. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
5.7.4 decomposição em valores singulares e determinantes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
5.7.5 mínimos quadrados montagem e a decomposição QR. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
5.8 formando matrizes particionadas, cbind () e rbind (). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
5.9 A função concatenação, c (), com matrizes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
5.10 tabelas de frequência de fatores. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
6 Lista e quadros de dados. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26

6.1 Listas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
6.2 Construção e modificação de listas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
6.2.1
6 2 1 Conca
Concatenação
enação de listas.
s as . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
6 3 Os quad os de dados 27
6 3 1 Fazendo quad os de dados 27
6 3 2 anexa e sepa a 28
6 3 3 T aba hando com quad os de dados 28
6 3 4 Co oca s as a b á as 28
6 3 5 Ge enc ando o cam nho de pesqu sa 29
7 Dados e tura de arqu vos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30

7 1 A ead ab e unção 30
7 2 A D g a za unção 31
7 3 Acessando con un os de dados embu das 31
7 3 1 Ca egando dados de ou os paco es R 31
7 4 dados Ed ção 32
8 As d s r bu ções de probab dade 33

8 1 R como um con un o de quad os es a s cos 33
8 2 Aná se da d s bu ção de um con un o de dados 34
8 3 um e do s es es de amos a 36
9 Agrupamento, oops e execução cond c ona . . . . . . . . . . . . . . . . . 40

9 1 exp essões ag upados 40
9 2 ns uções de con o e 40
9 2 1 Execução cond c ona E se a mações 40
9 2 2 execução epe vo pa a o ações epe e enquan o 40
10 Escrevendo suas própr as funções. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42

10 1 exemp os s mp es 42
10 2 de n ção de novos ope ado es b ná os 43
10 3 a gumen os e pad ões nomeado 43
10 4 O a gumen o 44
10 5 A bu ções den o de unções 44
10 6 exemp os ma s avançados 44
10 6 1 a o es de e c ênc a em p o e os b oco 44
10 6 2 La gando odos os nomes em uma ma z mp essa 45
10 6 3 n eg ação numé ca ecu s va 45
10 7 Scope 46
10 8 Pe sona zando o amb en e 48
10 9 c asses as unções gené cas e o en ação po ob ec os 48
iii
11 Os modelos estatísticos em R. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
11.1 Definindo modelos estatísticos; fórmulas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
11.1.1 contrastes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
11.2 modelos lineares. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
11.3 funções genéricas para extrair informações do modelo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
11,4 análise de variância e comparação de modelos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
11.4.1 tabelas ANOVA. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
11,5 Actualização dos modelos montados. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
11.6
11 6 mode
modelos
os lineares
nea es gene
generalizados.
a zados . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
11 6 1 am as 57
11 6 2 O GLM unção 57
11 7 m n mos quad ados não nea e mode os máx ma ve oss m hança 59
11 7 1 dos m n mos quad ados 59
11 7 2 p obab dade máx ma 61
11 8 A guns mode os não pad ão 61
12 proced mentos gráf co. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63

12 1 comandos p o agem de a o n ve 63
12 1 1 O en edo unção 63
12 1 2 Ex b ndo dados mu va ados 64
12 1 3 ep esen ação g á ca 64
12 1 4 a gumen os pa a unções de p o agem de a o n ve 65
12 2 comandos p o agem de ba xo n ve 66
12 2 1 ano ação ma emá ca 67
12 2 2 on es ve o a s He shey 67
12 3 n e ag ndo com g á cos 67
12 4 Usando pa âme os g á cos 68
12 4 1 mudanças pe manen es Os pa unção 68
12 4 2 mudanças empo á as A gumen os pa a unções g á cas 69
12 5 G á cos s a de pa âme os 69
12 5 1 e emen os g á cos 70
12 5 2 Axes e ma cas de esca a 71
12 5 3 ma gens gu a 71
12 5 4 Mu p e amb en e gu a 73
12 6 d ve s de d spos vo 74
d ag amas 12 6 1 Pos Sc p pa a documen os ypese 74
12 6 2 Vá os d spos vos g á cos 75
12 7 g á cos d nâm cos 76
13 Pacotes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77
13 1 paco es pad ão 77
13 2 paco es de Con bu ção e CRAN 77
13 3 namespaces 78
14 nsta ações OS. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79

14 1 a qu vos e d e ó os 79
14 2 Cam nhos de a qu vos 79
comandos 14 3 S s ema 80
14 4 comp essão e A qu vos 80
sessão de exemp o AA apênd ce. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82

iv
Apêndice B Invocando R. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85
B.1 Invocando R partir da linha de comando. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85
B.2 Invocando R no Windows. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89
B.3 Invocando R sob macos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90
Script B.4 com R. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90
Apêndice C O editor de linha de comando. . . . . . . . . . . . . . . . . . . . . . . . 92

C.1 preliminares. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92
ações C.2 edição. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92
C.3
C 3 de linha
nha de comando resumo
esumo ed
editor.
o . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92
Função D apênd ce e índ ce var áve . . . . . . . . . . . . . . . . . . . . . 94
Apênd ce índ ce E Concept. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97
Referênc as Apênd ce F. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99
1
Prefácio
Esta introdução de R é derivado de um conjunto inicial de notas descrevendo o S e S-Plus

ambientes escrito em 1990-2 por Bill Venables e David M. Smith quando da Universidade de Adelaide. Fizemos uma série de
pequenas mudanças para refletir diferenças entre os programas de R e S, e expandiu algum do material.
Nós gostaríamos de agradecer calorosamente a Bill Venables (e David Smith) para a concessão de permissão para
distribuir esta versão modificada das notas desta forma, e por ser um defensor da R do caminho de volta.
Comentários e correções são sempre bem vindos. Por favor, abordar e-mail a correspondência para
R-core@R-project.org.
Sugestões para o leitor

A maioria dos novatos R começará com a sessão introdutória no Apêndice A. Isto deve dar alguma familiaridade com o estilo de
sessões R e mais importante algum feedback instantâneo sobre o que realmente acontece.
Muitos usuários chegará a R principalmente por suas instalações gráficas. Consulte o Capítulo 12 [Graphics], página 63, que pode
ser lido em quase todo o tempo e não precisa esperar até que todas as seções anteriores foram digeridos.
2
1 Introdução e preliminares
1.1 O ambiente R
R é um conjunto integrado de instalações de software para manipulação de dados, cálculo e visualização gráfica. Entre outras
coisas, ele tem
• uma manipulação de dados eficaz e facilidade de armazenamento,
• um conjunto de operadores para cálculos em matrizes, em matrizes particulares,
• um grande coerente coleção, e integrado de ferramentas intermediárias para análise de dados,
• instalações gráficas para análise de dados e visualização seja diretamente no computador ou em cópia impressa e
• , Uma linguagem de programação simples e eficaz bem desenvolvido (chamado 'S'), que inclui condicionais, loops,
definidos pelo usuário funções recursivas e facilidades de entrada e saída. (Na verdade a maioria das funções do sistema
fornecido se estão escritos na linguagem S).
O termo “meio ambiente” se destina a caracterizá-lo como um sistema totalmente planejada e coerente, em vez de um acréscimo
incremental de ferramentas muito específicas e inflexíveis, como é frequentemente o caso com outro software de análise de dados.
R é muito mais um veículo por métodos de análise de dados interactiva desenvolver recentemente. Ele desenvolveu-se rapidamente,
e foi prorrogado por uma grande coleção de pacotes. No entanto, a maioria dos programas escritos em R são essencialmente efêmero,
escrito para uma única peça de análise de dados.
1.2 software relacionados e documentação

R pode ser considerado como uma implementação da linguagem S, que foi desenvolvido no Bell Laboratories por Rick Becker,
John Chambers e Allan Wilks, e também forma a base da S-Plus
sistemas.
A evolução da linguagem S é caracterizado por quatro livros por John Chambers e co-autores. Para R, a referência de base
é A Nova S Idioma: um ambiente de programação para análise de dados e gráficos por Richard A. Becker John M. Chambers e
Allan R. Wilks. Os novos recursos da versão de S 1991 são cobertos em Modelos estatísticos em S editado por John
M. Chambers e Trevor J. Hastie. Os métodos formais e classes da métodos pacote são baseados naqueles descritos em Programação
com dados por John M. Chambers. Veja o Apêndice F [Referências], página 99, para referências precisas.
Há agora um número de livros que descrevem como usar R para análise de dados e estatísticas e documentação para S / S-Plus
pode ser tipicamente utilizada com R, mantendo-se as diferenças entre as implementações S em mente. Veja a Seção “Que
documentação existe para R?” Em O FAQ sistema estatístico R.
1.3 R e estatísticas
Nossa introdução ao meio ambiente R não mencionou Estatisticas, No entanto, muitas pessoas usam R como um sistema de
estatísticas. Preferimos pensar sobre isso de um ambiente no qual muitas técnicas estatísticas clássicas e modernas foram
implementadas. Algumas delas estão incorporados no ambiente de base R, mas muitos são fornecidos como pacotes. Há cerca
de 25 pacotes fornecidos com R (chamado “padrão” e “recomendado” pacotes) e muitos mais estão disponíveis através da
família CRAN de sites Internet (via https://CRAN.R-project.org) e em outro lugar. Mais detalhes sobre pacotes são dadas mais
tarde (ver Capítulo 13 [Pacotes], página 77).
A maioria das estatísticas clássicas e grande parte da mais recente metodologia está disponível para uso com R, mas os usuários podem precisar estar
preparado para fazer um pouco de trabalho para encontrá-lo.

Capítulo 1: Introdução e preliminares 3
Existe uma diferença importante na filosofia entre S (e, portanto, R) e os outros sistemas estatísticos principais. Em S uma
análise estatística é normalmente realizado como uma série de passos, com os resultados intermédios de ser armazenado em
objectos. Assim, enquanto SAS e SPSS vai dar saída abundante a partir de uma análise de regressão ou discriminante, R dará
saída mínima e armazenar os resultados de um objecto em forma de interrogação subsequente por outras funções R.
1,4 o sistema de janelas e R

A maneira mais conveniente de usar R está em uma estação de trabalho gráficos executando um sistema de janelas. Este guia é
destinado a usuários que têm essa facilidade. Em particular, referem-se ocasionalmente para o uso de R em um sistema de janelas
X, embora a grande maioria do que é dito aplica-se geralmente a qualquer implementação do ambiente R.
A maioria dos usuários vai achar que é necessário para interagir diretamente com o sistema operacional em seu computador de
vez em quando. Neste guia, vamos discutir principalmente a interação com o sistema operacional em máquinas UNIX. Se você estiver
executando R sob o Windows ou MacOS você vai precisar fazer alguns pequenos ajustes.
Configurar uma estação de trabalho para tirar o máximo proveito dos recursos de personalização de R é um procedimento simples, se
um tanto tedioso, e não será considerado ainda mais aqui. Usuários em dificuldade deve procurar ajuda especializada local.
1.5 Uso R interactivamente

Quando você usa o programa R emite um aviso quando se espera que os comandos de entrada. O prompt padrão é '>', que no
UNIX pode ser o mesmo que o prompt shell, e assim pode parecer que nada está acontecendo. No entanto, como veremos, é
fácil mudar para um prompt de R diferente, se desejar. Vamos supor que o prompt shell UNIX é '$'.
Em usando R em UNIX o procedimento sugerido para a primeira ocasião é a seguinte:

1. Criar um sub-diretório separado, digamos trabalhos, para armazenar arquivos de dados em que você vai usar R para
este problema. Este será o diretório de trabalho sempre que você usar R para este problema particular.
$ Mkdir work work

$ cd
2. Inicie o programa R com o comando
$R
3. Neste ponto, pode ser emitido comandos R (ver mais adiante).
4. Para sair do programa R o comando é

> Q ()
Neste ponto, você será perguntado se você deseja salvar os dados da sessão R. Em alguns sistemas isto irá abrir uma
caixa de diálogo, e em outros, você receberá um aviso de texto para que você possa responder sim não ou cancelar ( um
único letras vai fazer) para salvar os dados antes de sair, sair sem salvar, ou retornar para a sessão R. Os dados que é
salvo estará disponível em sessões de R futuras. Outras sessões R são simples.
1. Faça trabalhos o diretório de trabalho e iniciar o programa como antes:

$ Cd trabalho $
R
2. Utilize o programa R, terminando com o q () comando no final da sessão. Para usar R no Windows o procedimento a seguir
é basicamente o mesmo. Criar uma pasta como o diretório de trabalho e definir que no Começar campo em seu atalho R. Em
seguida, inicie R clicando duas vezes sobre o ícone.
1.6 Uma sessão introdutória

Os leitores que desejam obter uma sensação de R em um computador antes de prosseguir são fortemente aconselhados a trabalhar com a
sessão introdutória No apêndice A [A sessão de exemplo], página 82.
1.7 Obter ajuda com funções e características

R tem uma facilidade de ajuda embutido semelhante ao homem facilidade de UNIX. Para obter mais informações sobre qualquer função
chamada específica, por exemplo resolver, o comando é
> ajuda (resolver)
Uma alternativa é
> ?resolver
Para um recurso especificado por caracteres especiais, o argumento deve ser colocado entre aspas duplas ou individuais, tornando-se
uma “cadeia de caracteres”: Isto também é necessário para algumas palavras com significado sintático incluindo se, por e função.
> Socorro("[[")
De qualquer forma de aspas pode ser usado para escapar da outra, como no string " É importante". Nossa convenção é usar
aspas duplas para a preferência.
Na maioria das instalações de P ajuda está disponível em formato HTML, executando
> help.start ()
que irá lançar um navegador da Web que permite que as páginas de ajuda para ser navegado com hiperlinks. No UNIX, os pedidos de
ajuda subsequentes são enviados para o sistema de ajuda baseado em HTML. O link 'Search Engine e palavras-chave' na página
carregada por help.start () é particularmente útil, pois é contém uma lista conceito de alto nível que procura embora as funções
disponíveis. Pode ser uma ótima maneira de se orientar rapidamente e compreender a amplitude do que R tem para oferecer.
o help.search comando (alternativamente ??) permite procurar ajuda de várias maneiras. Por exemplo,
> ??resolver
Experimentar ? help.search para detalhes e mais exemplos. Os exemplos de um tópico
de ajuda pode normalmente ser executado por
> exemplo( tópico)
A versões Windows do R ter outros sistemas de ajuda opcionais: uso
> ?Socorro
para mais detalhes.
1,8 comandos R, sensibilidade caso, etc.

Tecnicamente o símbolo R representa um linguagem de expressão com uma sintaxe muito simples. Isto é maiúsculas e Minúsculas como são a
maioria dos pacotes baseados em UNIX, então UMA e uma são símbolos diferentes e que se referem a diferentes variáveis. O conjunto de
símbolos que podem ser usados em nomes de R depende do sistema operacional e do país no qual R está sendo executado (tecnicamente na localidade
em uso). Normalmente todos os símbolos alfanuméricos são permitidos 1 ( e em alguns países isso inclui letras acentuadas) mais '' e '_', com a
restrição de que um nome deve começar com ''. ou uma carta, e se ele começa com ''. a segunda personagem não deve ser um dígito. Os
nomes são efetivamente ilimitado de comprimento.
comandos elementares consistem em qualquer expressões ou atribuições. Se uma expressão é dada como um comando, é
avaliada, impresso (a menos que especificamente tornada invisível), e o valor é perdido. Uma atribuição também avalia uma
expressão e passa o valor de uma variável, mas o resultado não é impressa automaticamente.
1 Para código de R portátil (incluindo aquela para ser usado em pacotes R), apenas A-Za-Z0-9 deve ser usado.
Os comandos são separados por um ponto e vírgula ( ';'), ou por uma nova linha. comandos elementares podem ser
agrupadas em uma expressão composto por cintas ( '{' e '}'). Comentários pode ser colocado quase 2 em qualquer lugar,
começando com uma insígnia ( '#'), tudo para o fim da linha é um comentário.
Se um comando não está completa no final de uma linha, R dará um prompt diferente, por padrão
na segunda e subsequentes linhas e continuar a ler a entrada até que o comando é sintacticamente completa. Essa solicitação
pode ser alterado pelo usuário. Nós geralmente omitir o prompt de continuação e indicam continuação por simples recuo.
linhas de comando inseridas no console são limitados 3 a cerca de 4095 bytes (não caracteres).
1.9 Recall e correção dos comandos anteriores

Sob muitas versões do UNIX e no Windows, R fornece um mecanismo para chamar e reexecuting comandos anteriores. As teclas de
seta verticais no teclado pode ser usado para se deslocar para a frente e para trás através de um histórico de comandos. Uma vez que
um comando está localizado nesta maneira, o cursor pode ser deslocado no interior do comando utilizando as teclas de setas
horizontais, e os caracteres podem ser removidos com o DEL chave ou adicionado com as outras chaves. Mais detalhes são fornecidos
mais tarde: vide Anexo C [O editor de linha de comando], página 92.
As capacidades de recall e edição sob UNIX são altamente personalizáveis. Você pode descobrir como fazer isso lendo a
entrada manual para o Leia a linha biblioteca.
Alternativamente, o editor de texto Emacs fornece mecanismos de apoio mais gerais (via ESS,
Emacs Fala Estatística) para trabalhar interativamente com R. Consulte a seção “R e Emacs” em O FAQ sistema estatístico R.
1.10 A execução de comandos a partir de ou desviar saída para um arquivo

Se os comandos 4 são armazenados em um arquivo externo, dizem commands.R no diretório de trabalho trabalhos, eles podem ser executados a
qualquer momento numa sessão R com o comando
> fonte ( "commands.R")
Para Windows Fonte Também está disponível no Arquivo cardápio. A função Pia,
> afundar ( "record.lis")
desviará toda a saída posterior a partir do console para um arquivo externo, record.lis. O comando
> Pia()
restaura-lo para o console mais uma vez.
1,11 permanência de dados e objectos removendo

As entidades que R cria e manipula são conhecidos como objetos. Estes podem ser variáveis, matrizes de números, cadeias de
caracteres, funções ou estruturas mais gerais construídos a partir de tais componentes.
Durante uma sessão R, os objetos são criados e armazenados pelo nome (discutiremos esse processo na próxima seção). O
comando R
> (objectos)
(alternativamente, ls ()) pode ser usado para exibir os nomes de (a maioria) os objetos que estão atualmente armazenados dentro R. A coleção
de objetos armazenados atualmente é chamado de área de trabalho.
2 não dentro cordas, nem dentro da lista de argumentos de uma definição de função
3 alguns dos consoles não vai permitir que você digite mais, e entre aqueles que fazer alguma irá silenciosamente descartar
o excesso e alguns vão usá-lo como o início da próxima linha.

4 deduração ilimitada.
6
Para remover objetos da função rm está disponível:
> RM (x, y, z, tinta, lixo, temp, foo, bar)
Todos os objetos criados durante uma sessão de R podem ser armazenados permanentemente em um arquivo para uso em sessões R
futuras. No final de cada sessão R é-lhe dada a oportunidade de salvar todos os objetos disponíveis atualmente. Se você indicar que você quer
fazer isso, os objetos são gravados em um arquivo chamado
. RDATA 5 no diretório atual, e as linhas de comando usados na sessão são salvos em um arquivo chamado. Rhistory.
Quando R é iniciado no momento mais tarde do mesmo diretório que recarrega o espaço de trabalho a partir deste arquivo. Ao mesmo
tempo, a história comandos associado é recarregado.
Recomenda-se que você deve usar diretórios de trabalho separados para análises conduzidas com R. É bastante comum
para objetos com nomes X e y a ser criado durante uma análise. Nomes como este são muitas vezes significativos no contexto
de uma única análise, mas ele pode ser bastante difícil decidir o que pode ser quando as várias análises foram realizadas no
mesmo diretório.
5O “ponto” líder neste nome do arquivo torna invisível em listas de arquivos normais em UNIX, e em arquivo de GUI padrão
listagens no MacOS e Windows.

7
2 manipulações simples; números e vectores
2.1 Vetores e atribuição

R opera com o nome estruturas de dados. O mais simples tal estrutura é a numérico vetor, que é uma entidade única, que consiste
em uma coleção ordenada de números. Para configurar um vetor chamado x,
dizer, consistindo de cinco números, ou seja, 10.4, 5.6, 3.1, 6.4 e 21.7, usar o comando de R
> x <- c (10,4, 5,6, 3,1, 6,4, 21,7)
Isto é um tarefa declaração usando o função c () que neste contexto pode ter um número arbitrário de vetor argumentos e
cujo valor é um vetor tem concatenando os seus argumentos de ponta a ponta. 1
Um número ocorrendo por si numa expressão é tomada como um vector de comprimento um. Observe que o operador de
atribuição ( '<-'), que consiste em dois caracteres '<' ( “menos do que”) e '-' ( “menos”) que ocorre estritamente lado-a-lado e
'pontos' para o objeto receber o valor da expressão. Na maior parte dos contextos, o operador '=' pode ser utilizado como uma
alternativa.
Atribuição também pode ser feita usando a função atribuir(). Uma maneira equivalente de fazer a mesma tarefa como acima
é com:
> atribuir ( "x", c (10,4, 5,6, 3,1, 6,4, 21,7))
O operador de costume, <-, pode ser pensado como um sintática atalho para isso.
Atribuições também pode ser feita em outra direção, usando a mudança óbvia no operador de atribuição. Assim, a mesma
atribuição poderia ser feito usando
> C (10,4, 5,6, 3,1, 6,4, 21,7) -> x
Se a expressão é utilizada como um comando completo, o valor é impresso e perdido 2. Portanto, agora se tivéssemos que usar o
comando
>1/x
os recíprocos dos cinco valores seria impresso no terminal (e o valor de x, é claro, inalterado).
Quanto mais atribuição
> y <- c (x, 0, x)
criaria um vector y com 11 entradas, constituídos por duas cópias de X com um zero no lugar do meio.
aritmética 2.2 Vector

Os vectores podem ser utilizados nas expressões aritméticas, caso em que as operações são executadas elemento por elemento. Os
vectores que ocorrem na mesma expressão não precisam ser todos do mesmo comprimento. Se eles não são, o valor da expressão é
um vector com o mesmo comprimento que o vector mais longa que ocorre na expressão. Os vectores mais curtos na expressão são reciclado
tantas vezes quanto necessário (talvez fracionada) até coincidir com o comprimento do vetor mais longo. Em particular, uma constante é
simplesmente repetidos. Assim, com as atribuições acima do comando
> v <- 2 * x + y + 1
gera um novo vetor v de comprimento 11 construído pela soma, elemento por elemento, 2 * x
repetidas 2,2 vezes, y repetido apenas uma vez, e 1 repetido 11 vezes.
1 Com excepção tipos vetor de argumento, como Lista argumentos modo, a ação da c () é bastante diferente.
Veja Seção 6.2.1 [listas Concatenação], página 27.

2 Na verdade, ele ainda está disponível como. Last.value antes de quaisquer outras instruções são executadas.
Capítulo 2: manipulações simples; números e vectores 8
Os operadores aritméticos elementares são os habituais +, -, *, / e ^ para elevar a uma potência. Além de todas as funções
aritméticas comuns estão disponíveis. log, exp, sin, cos, tan, sqrt,
e assim por diante, todos têm o seu significado usual. max e min selecionar os elementos maiores e menores de um vetor,
respectivamente. alcance é uma função cujo valor é um vector de comprimento dois, a saber c (min (x), max (x)). comprimento (x) é o
número de elementos em x, soma (x) dá o total dos elementos em
x, e prod (x) seu produto.
Duas funções estatísticas são significa (x) que calcula a média da amostra, o que é o mesmo que soma (x) / comprimento
(x), e var (x) que dá
soma ((x-média (x)) ^ 2) / (comprimento (x) -1)
ou variância da amostra. Se o argumento para var () é um n- por- p matriz o valor é um p por- p matriz da amostra covariância tem por
sobre as linhas como independente p vectores de amostra variado.
sort (x) retorna um vector do mesmo tamanho X com os elementos dispostos em ordem crescente; no entanto, existem outras
instalações de classificação mais flexíveis disponíveis (ver ordem() ou sort.list ()
que produzem uma permutação para fazer a classificação).
Observe que max e min selecionar os valores maiores e menores em seus argumentos, mesmo se eles são dados vários vetores.
o paralelo funções máximos e mínimos pmax e pmin retornar um vector (de comprimento igual ao seu argumento mais longo) que
contém em cada elemento do maior elemento (o mais pequeno) em que a posição em qualquer um dos vectores de entrada.
Na maioria dos casos o usuário não vai se preocupar se os “números” em um vetor numérico são inteiros, reais ou até mesmo
complexo. cálculos internamente, são feitos como números reais de precisão dupla, ou números complexos de precisão dupla, se
os dados de entrada são complexas.
Para trabalhar com números complexos, fornecer uma parte complexa explícito. portanto
sqrt (-17)
darei NaN e um aviso, mas
sqrt (-17 + 0i)
vai fazer os cálculos como números complexos.
2.3 Geração de sequências regularmente

R tem um número de dispositivos para a geração de sequências de números comumente utilizados. Por exemplo
01:30 é o vetor c (1, 2, ..., 29, 30). O operador do cólon tem alta prioridade dentro de uma expressão, de modo que, por exemplo
2 * 1: 15 é o vetor c (2, 4, ..., 28, 30). Colocar n <- 10 e comparar as sequências 1: N-1 e 1: (n-1).
A construção 30: 1 pode ser usado para gerar uma sequência para trás. A função seq () é uma instalação mais geral para a
geração de sequências. Ele tem cinco argumentos, dos quais apenas alguns podem ser especificados em qualquer uma chamada.
Os primeiros dois argumentos, se for dada, especificar o início e fim da sequência, e se estes forem os únicos dois argumentos
fornecidos o resultado é o mesmo que o operador do cólon. Isso é seq (2,10) é o mesmo vector que 2:10.
argumentos para seq (), e muitas outras funções R, também pode ser dada em forma chamado, caso em que a ordem em que
aparecem é irrelevante. Os primeiros dois argumentos podem ser nomeados
de = valor e to = valor; portanto seq (1,30), seq (a partir de = 1, a = 30) e seq (a = 30, a partir de = 1)
são todos o mesmo que 1.30. Os próximos dois argumentos para seq () pode ser nomeado por = valor e
comprimento = valor, que especificam um tamanho de passo e um comprimento para a sequência, respectivamente. Se nenhuma dessas é dada, o
padrão por = 1 é assumido.
Por exemplo
> seq (-5, 5, por = 0,2) -> s3
gera em s3 o vetor c (-5,0, -4,8, -4,6, ..., 4.6, 4.8, 5.0). similarmente
> s4 <- SEQ (comprimento = 51, a partir de = -5, por = 0,2)

gera o mesmo vector em S4.

O quinto argumento pode ser nomeado juntamente = vetor, que é normalmente utilizado como o único argumento para criar a
sequência 1, 2, ..., comprimento ( vetor), ou a sequência de vazio se o vector está vazio (como pode ser).
Uma função relacionada é rep () que pode ser usado para replicar um objeto de várias formas complicadas. A forma mais
simples é
> S5 <- rep (x, vezes = 5)
que irá colocar cinco cópias X end-to-end S5. Outra versão é útil
> S6 <- rep (x, cada = 5)
que repete cada elemento de X cinco vezes antes de passar para a próxima.
2.4 vectores lógicos

Assim como vectores numéricos, R permite a manipulação de quantidades lógicos. Os elementos de um vetor lógico pode ter os valores VERDADEIRO
FALSO, e N / D ( para “não disponível”, veja abaixo). Os dois primeiros são muitas vezes abreviado como T e F, respectivamente. Note no
entanto que T e F são apenas variáveis que estão definidos para VERDADE e FALSO por padrão, mas não são palavras reservadas e,
portanto, pode ser substituída pelo usuário. Assim, você deve sempre usar VERDADE e FALSO.
vectores lógicas são gerados pela condições. Por exemplo

> Temp <- x> 13
conjuntos Temp como um vector do mesmo comprimento que X com valores FALSO correspondente a elementos de X
onde a condição é não conheceu e VERDADE onde está.
Os operadores lógicos são <, <=,>,> =, == pela igualdade exata e! = para a desigualdade. Além disso, se c1 e c2 são
expressões lógicas, em seguida, c1 e c2 é sua interseção ( "e"), c1 | c2 é a sua união ( "ou"), e! c1 é a negação de c1.
vetores lógicos podem ser usados na aritmética ordinária, caso em que eles são coagidos em vectores numéricos, FALSO tornando-se
0 e VERDADE tornando-se 1. No entanto, existem situações em que vetores lógicos e os seus homólogos numéricos forçadas não
são equivalentes, por exemplo, ver a próxima subseção.
2,5 valores que faltam

Em alguns casos, os componentes de um vector não pode ser completamente conhecida. Quando um elemento ou valor é “não
disponível” ou um “valor em falta” no sentido estatístico, um lugar dentro de um vetor pode ser reservada para ele, atribuindo a ela o
valor especial N / D. Em geral, qualquer operação em um N / D
torna-se um N / D. A motivação para esta regra é simplesmente que se a especificação de uma operação é incompleta, o resultado não
pode ser conhecido e, portanto, não está disponível.
A função is.na (x) dá um vetor lógico do mesmo tamanho X com valor VERDADE Se e só se o elemento correspondente
em X é N / D.
> z <- c (1: 3, NA); ind <- is.na (z)
Observe que a expressão lógica x == NA é bastante diferente do is.na (x) Desde a N / D não é realmente um valor, mas um marcador
para uma quantidade que não está disponível. portanto x == NA é um vector do mesmo comprimento que X todos de cujos valores são N / D como
a expressão lógica própria é incompleta e, portanto, indecidible.
Note que existe um segundo tipo de valores “perdidos” que são produzidas por computação numérica, o chamado Não é
um número, NaN, valores. Exemplos são
> 0/0
ou
> Inf - Inf

que ambos dão NaN uma vez que o resultado não pode ser definido de forma sensata.
Em suma, is.na (xx) é VERDADE ambos para N / D e NaN valores. Para diferenciar estas,
is.nan (xx) é apenas VERDADE para NaN s. valores em falta são, por vezes, impresso como < NA> quando vetores de caracteres são
impressas sem aspas.
2,6 vetores de caracteres

quantidades de caracteres e vetores de caracteres são usados frequentemente em R, por exemplo, como etiquetas de enredo. Sempre que
necessário eles são indicados por uma sequência de caracteres delimitados pelo caractere de aspas duplas, por exemplo ", x-valores", "Novos
resultados de iteração".
cadeias de caracteres são inseridos usando correspondência duplas ( ") ou simples ( ') citações, mas são impressos usando
aspas duplas (ou às vezes sem aspas). Eles usam sequências de escape de estilo C, usando \ como o caractere de escape,
então \\ é digitado e impresso como \\, e dentro de aspas "é inserido como \". Outras sequências de escape úteis são \ N, nova
linha, \ t, guia e \ b, backspace-ver
?Citações para uma lista completa.
vectores de caracteres podem ser concatenados num vector pela c () função; exemplos de seu uso vão surgir com
freqüência.
o colar() função recebe um número arbitrário de argumentos e concatena-los um por um para cadeias de caracteres.
Quaisquer números indicados entre os argumentos são coagidos a cadeias de caracteres na forma evidente, isto é, da mesma
forma que seria se eles foram impressos. Os argumentos são separados por padrão no resultado por um único caractere em
branco, mas isso pode ser alterado pelo argumento nomeado, sep = corda, que altera para corda, possivelmente vazio.
Por exemplo
> laboratórios <- colar (c ( "X", "Y"), 01:10, setembro = "")
marcas laboratórios para o vector caráter
c ( "X1", "Y2", "X3", "Y4", "X 5", "Y6", "X7", "Y8", "X 9", "Y10")
Nota particularmente que a reciclagem de listas curtas acontece aqui também; portanto c ( "X", "Y") é repetido 5 vezes para
igualar a sequência 1:10. 3
2.7 vectores de índice; seleccionar e modificar subconjuntos de um conjunto de dados
Subconjuntos dos elementos de um vector pode ser seleccionado pelo anexação o nome do um vector de
vetor índice entre colchetes. Mais geralmente, qualquer expressão que resulta em um vector pode ter subconjuntos de seus
elementos seleccionados de forma semelhante anexando um vector de índice em colchetes imediatamente após a expressão.
Tais vectores de índice pode ser qualquer um dos quatro tipos distintos.
1. Um vetor lógico. Neste caso, o vector de índice é reciclado para o mesmo comprimento que o vetor
a partir do qual os elementos estão a ser seleccionados. Os valores correspondentes ao VERDADE no vector de índice são seleccionados e
os correspondentes aos FALSO são omitidos. Por exemplo
> y <- x [! is.na (x)]
cria (ou recria) um objecto y que irá conter os valores não ausentes de x, na mesma ordem. Note que se X tem valores em
falta, y será menor do que x. Além disso
> (X + 1) [(! Is.na (x)) & x> 0] -> z
cria um objecto z e os lugares em que os valores do vector x + 1 para o qual o valor correspondente em X era ao mesmo
tempo não falta e positiva.
3 colar (..., colapso = ss) junta-se aos argumentos em uma única cadeia de caracteres colocando ss entre, por exemplo, ss
<- "|". Há mais ferramentas para manipulação de caracteres, consulte a ajuda para sub e substring.
2. Um vector de quantidades integrais positivos. Neste caso, os valores no vector índice deve situar
no conjunto {1, 2,. . . , comprimento (x)}. Os elementos correspondentes do vector são seleccionados e concatenados, naquela
ordem, no resultado. O vector de índice pode ser de qualquer comprimento e o resultado é do mesmo comprimento que o vector
de índice. Por exemplo x [6] é o sexto componente de X e
> x [01:10]
selecciona os primeiros 10 elementos de x ( assumindo comprimento (x) não é inferior a 10). Além disso
> c ( "x", "y") [rep (c (1,2,2,1), os tempos = 4)]
(Uma coisa reconhecidamente improvável que o faça) produz um vetor de caracteres de comprimento 16 consistindo de
"X", "y", "y", "x" repetido quatro vezes.
3. Um vector de quantidades integrais negativos. Tal vector índice especifica os valores a ser
excluídos em vez de incluídos. portanto
> y <- X [- (1: 5)]
dá y todos, mas os primeiros cinco elementos da x.
4. Um vector de cadeias de caracteres. Esta possibilidade só se aplica quando um objeto tem uma nomes
atributo para identificar seus componentes. Neste caso, um sub-vector do vector nomes podem ser utilizados na mesma maneira
como as etiquetas integrais positivos no item 2 mais acima.
> fruta <- c (5, 10, 1, 20)

> nomes (fruta) <- c ( "laranja", "banana", "maçã", "pêssego")
> almoço <- fruto [c ( "apple", "laranja")]
A vantagem é que alfanumérico nomes são muitas vezes mais fácil de lembrar do que índices numéricos. Esta opção é
particularmente útil em conexão com quadros de dados, como veremos mais tarde.
Uma expressão indexada também pode aparecer na extremidade de recebimento de uma tarefa, no caso em que é
realizada a operação de atribuição apenas nos elementos do vector. A expressão deve ser de forma vetor[ index_vector] como
tendo uma expressão arbitrária no lugar do nome do vetor não faz muito sentido aqui.
Por exemplo
> x [is.na (x)] <- 0
substitui quaisquer valores em falta no X e por zeros
> y [y <0] <- -y [y <0]
tem o mesmo efeito que
> y <- abs (y)
2.8 Outros tipos de objectos

Vetores são o tipo mais importante de objeto em R, mas existem vários outros que vamos atender mais formalmente em seções
posteriores.
• matrizes ou, mais geralmente matrizes são generalizações multi-dimensional de vectores. Na verdade, eles está vetores que podem
ser indexados por dois ou mais índices e serão impressas de formas especiais. Consulte o Capítulo 5 [matrizes e matrizes], página
18.
• fatores proporcionar meios compactos para lidar com dados categóricos. Consulte o Capítulo 4 [Fatores], página 16.
• listas são uma forma geral de vector em que os vários elementos não precisa ser do mesmo tipo, e são frequentemente eles
mesmos vectores ou listas. Listas fornecem uma maneira conveniente para retornar os resultados de um cálculo estatístico. Veja
Seção 6.1 [Listas], página 26.
• quadros de dados são estruturas de matriz semelhante, na qual as colunas podem ser de diferentes tipos. Pense em quadros de dados como
'matrizes de dados' com uma linha por unidade de observação, mas com (possivelmente)
ambas as variáveis numéricas e categóricas. Muitas experiências são melhor descritos por quadros de dados: os tratamentos
são categóricos mas a resposta é numérico. Veja Seção 6.3 [Os quadros de dados], página 27.
• funções são eles próprios objetos em R que pode ser armazenado em espaço de trabalho do projeto. Isso fornece uma maneira
simples e conveniente para estender R. Consulte o Capítulo 10 [escrever suas próprias funções], página 42.
13
3 objetos, seus modos e atributos
3.1 atributos intrínsecos: o modo e comprimento

As entidades R opera em são tecnicamente conhecido como objetos. Exemplos são vetores de numérico (real) ou valores complexos,
vetores de valores lógicos e vetores de cadeias de caracteres. Estes são conhecidos como estruturas “atômicas”, já que seus
componentes são todos do mesmo tipo, ou modo, nomeadamente
numérico 1, complexo, lógico, personagem e cru.
Vetores devem ter seus valores todos do mesmo modo. Assim qualquer dado vector deve ser inequivocamente tanto lógico,
numérico, complexo, de caráter ou cru. ( A única exceção aparente a esta regra é o “valor” especial listado como N / D para
quantidades não estão disponíveis, mas na verdade, existem vários tipos de N / D). Note-se que um vetor pode ser vazio e ainda
ter um modo. Por exemplo, o vector cadeia de caracteres vazia é listado como caracteres (0) e o vector vazio como numérico
numérico (0).
R também opera em objetos chamados listas, que são de modo Lista. Estes são ordenados seqüências de objetos que, individualmente,
podem ser de qualquer modo. listas são conhecidos como estruturas “recursiva” em vez de atômicas desde os seus próprios componentes
podem ser listas em seu próprio direito.
As outras estruturas recursivas são aqueles de modo função e expressão. Funções são os objetos que fazem parte do sistema
R juntamente com funções de usuário escrito semelhantes, que serão discutidos com algum detalhe mais tarde. Expressões como
objetos fazem parte avançada de R que não serão discutidos neste guia, exceto indiretamente quando discutimos fórmulas utilizado
com modelagem em R.
Pelo modo de um objeto que queremos dizer o tipo básico de seus constituintes fundamentais. Este é um caso especial de uma
“propriedade” de um objeto. Outra propriedade de cada objeto é a sua comprimento. As funções modo( objeto) e comprimento( objeto) pode
ser utilizado para descobrir o modo e o comprimento de qualquer estrutura definida 2.
Outras propriedades de um objecto são normalmente fornecidos por atributos( objeto), ver Secção 3.3 [Obtendo e atributos de
configuração], página 14. Devido a isso, modo e comprimento Também são chamados de “atributos intrínsecos” de um objeto.
Por exemplo, se z é um vector complexo de comprimento de 100, em seguida, em uma expressão modo (z) é a cadeia de caracteres " complexo"
e comprimento (z) é 100.
R serve para mudanças de modo quase qualquer lugar que poderia ser considerado razoável para fazê-lo, (e alguns, onde ele pode
não ser). Por exemplo, com
> z <- 0: 9
poderíamos colocar
> dígitos <- (z) as.character
após o qual dígitos é o vetor de caracteres c ( "0", "1", "2", ..., "9"). Uma outra coerção, ou mudança de modo, reconstrói o vector
numérica novamente:
> d <- as.integer (dígitos)
Agora d e z são os mesmos. 3 Há uma grande coleção de funções da forma Como. alguma coisa()
para qualquer forma de coação de um modo para outro, ou para investir um objeto com algum outro atributo não pode já
possuir. O leitor deve consultar os diferentes arquivos de ajuda para se familiarizar com eles.
1 numérico modo é, na verdade, uma amálgama de dois modos distintos, a saber número inteiro e em dobro precisão, como explicado
no manual.
2 Noteno entanto que comprimento( objeto) nem sempre contêm informação útil intrínseca, por exemplo, quando objeto é
uma função.
3 Em geral, a coerção de numérico para caráter e de volta não será exatamente reversível, por causa da
erros de arredondamento na representação de caracteres.

Capítulo 3: objetos, seus modos e atributos 14
3,2 A alteração do comprimento de um objecto

Um objeto “vazio” pode ainda ter um modo. Por exemplo
> e <- numérico ()
marcas e uma estrutura de vector vazio de modo numérico. similarmente personagem() é um vetor de caracteres vazia, e assim por diante. Uma vez
que um objecto de qualquer tamanho foi criado, novos componentes podem ser adicionados a ele simplesmente, dando-lhe um valor de índice fora
da sua gama anterior. portanto
> e [3] <- 17
agora faz e um vector de comprimento 3, (os dois primeiros componentes de que são, neste ponto, tanto N / D).
Isto aplica-se a qualquer estrutura de todo, desde que o modo do componente (s) adicional está de acordo com o modo do
objecto em primeiro lugar.
Este ajustamento automático de comprimentos de um objecto é usado mais frequentemente, por exemplo, no Digitalizar ()
função de entrada. (Ver Secção 7.2 [A função de digitalização ()], página 31.)
Por outro lado truncar o tamanho de um objeto requer apenas uma atribuição para fazê-lo. portanto, se
alfa É um objecto do comprimento 10, então
> alfa <- alfa [2 * 1: 5]
faz com que seja um objecto de comprimento 5 consistindo de apenas os componentes anteriores com mesmo índice. (Os índices antigos não são
mantidos, é claro.) Podemos, então, reter apenas os primeiros três valores por
> comprimento (alfa) <- 3
e vectores podem ser estendido (por valores em falta) na mesma maneira.
3.3 obter e definir atributos

A função atributos( objeto) retorna uma lista de todos os atributos não-intrínsecas actualmente definidos para esse objecto. A
função attr ( objeto, nome) pode ser usado para selecionar um atributo específico. Estas funções são raramente usados, exceto
em circunstâncias bastante especiais quando algum novo atributo está sendo criado para um propósito particular, por exemplo,
para associar uma data de criação ou um operador com um objeto R. O conceito, no entanto, é muito importante.
Alguns cuidados devem ser exercidos ao atribuir ou excluir atributos uma vez que são parte integrante do sistema de objeto
usado no R.
Quando é usado no lado esquerdo de uma atribuição que pode ser usado tanto para associar um novo atributo com objeto ou
para alterar um já existente. Por exemplo
> attr (z, "dim") <- C (10,10)
permite R para tratar z como se se tratasse de uma matriz 10 por 10.
3.4 A classe de um objecto

Todos os objetos em R ter um classe, relatado pela função classe. Para vetores simples, isto é apenas o modo, por exemplo " numérico",
"Lógico", "caráter" ou " Lista", mas " matriz", "matriz", "factor de" e " quadro de dados" são possíveis outros valores.
Um atributo especial conhecido como o classe do objecto é usado para permitir a um estilo orientada a objectos 4 de programação
em R. Por exemplo, se um objeto tem classe " quadro de dados", ele será impresso de uma certa maneira, o enredo() função irá
exibi-lo graficamente de uma certa maneira, e outros chamados funções genéricas como resumo () vai reagir a ela como um
argumento de uma forma sensível a sua classe.
Para remover temporariamente os efeitos da classe, use a função unclass (). Por exemplo, se inverno
tem a classe " quadro de dados" então
> inverno
4 Um estilo diferente usando classes 'S4' 'formais' ou é fornecido no pacote métodos.

Capítulo 3: objetos, seus modos e atributos 15
vai imprimi-lo na forma de estrutura de dados, que é um pouco como uma matriz, enquanto
> unclass (inverno)
vai imprimi-lo como uma lista comum. Apenas em situações bastante especiais que você precisa para usar esta facilidade, mas um é quando
você está aprendendo a entrar em acordo com a idéia de classe e funções genéricas.
funções genéricas e as aulas serão debatidas na secção 10.9 [orientação Object], página 48, mas apenas brevemente.
16
4 factores ordenadas e não ordenadas
UMA fator é um objecto vector utilizado para especificar uma classificação discreta (agrupamento) dos componentes de outros vectores
do mesmo comprimento. R fornece tanto pedido e não ordenado fatores. Enquanto o aplicativo “real” de fatores é com fórmulas modelo
(ver Secção 11.1.1 [Contrastes], página 53), nós aqui olhar um exemplo específico.
4.1 Um exemplo específico

Suponha, por exemplo, temos uma amostra de 30 auditores fiscais de todos os estados e territórios da Austrália 1 e seu estado
individual de origem é especificado por um vector caráter de mnemônicos do Estado como
> estado <- c ( "TAS", "sa", "qld", "NSW", "NSW", "nt", "wa", "wa",
"Qld", "vic", "NSW", "vic", "qld", "qld", "sa", "TAS", "sa", "nt", "wa", "vic", "qld ", "NSW",
"NSW", "wa", "sa", "ato", "NSW", "vic", "vic", "age")
Observe que, no caso de um vetor de caracteres, “classificado” significa classificados em ordem alfabética. UMA fator é
igualmente criada usando o fator() função:
> statef <- fator (estado)
o impressão() função manipula fatores de forma ligeiramente diferente de outros 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 agir NSW vic Níveis vic act: ato NSW nt qld sa tas vic wa
Para saber os níveis de um fator a função (níveis) pode ser usado.
> níveis (statef)

[1] "ato" "NSW" "nt" "qld" "sa" "TAS" "vic" "wa"
4.2 A função tapply () e matrizes irregulares

Para continuar o exemplo anterior, suponha que temos os rendimentos dos mesmos auditores fiscais em outro vetor (em adequadamente
grandes unidades de dinheiro)
> rendimentos <- c (60, 49, 40, 61, 64, 60, 59, 54, 62, 69, 70, 42, 56,
61, 61, 61, 58, 51, 48, 65, 49, 49, 41, 48, 52, 46,
59, 46, 58, 43)
Para o cálculo da amostra de renda para cada estado significa agora podemos usar a função especial
tapply ():
> incmeans <- tapply (rendimentos, statef, quer dizer)
dando um vector de meios com os componentes marcados pelos níveis
Aja NSW nt qld sa tas vic wa

44,500 57,333 55,500 53,600 55,000 60,500 56,000 52,250
A função tapply () é usado para aplicar uma função, aqui significar(), para cada grupo de componentes do primeiro argumento,
aqui rendimentos, definido pelos níveis do segundo componente, aqui statef 2,
1 Os leitores devem notar que há oito estados e territórios da Austrália, ou seja, o Australian Capital
Território, Nova Gales do Sul, o Território do Norte, Queensland, Austrália do Sul, Tasmânia, Victoria e Austrália Ocidental.
2 Observe que tapply () também funciona neste caso, quando seu segundo argumento não é um fator, por exemplo, ' tapply (rendimento,
Estado) ', E isto é verdade para algumas outras funções, uma vez que os argumentos são coagidos a factores quando necessário (usando as.factor ()).
Capítulo 4: ordenado e não ordenadas fatores 17
como se fossem estruturas vector separado. O resultado é uma estrutura do mesmo comprimento que os níveis de atributo do
factor contendo os resultados. O leitor deve consultar o documento de ajuda para mais detalhes.
Suponha ainda que precisávamos para calcular os erros padrão das médias de renda do estado. Para fazer isso,
precisamos escrever uma função R para calcular o erro padrão para qualquer dado vetor. Desde há uma função interna var () para
calcular a variação da amostra, tal função é uma forma muito simples um forro, especificado pela atribuição:
> stderror <- função (x) sqrt (var (x) / comprimento (x))
(Funções de escrita serão considerados posteriormente no Capítulo 10 [Escrevendo suas próprias funções], página 42. Note-se que R
é uma função interna SD() é algo diferente.) Depois desta atribuição, os erros padrão são calculados por
> incster <- tapply (rendimentos, statef, stderror)
e os valores calculados são então
> ato incster

nsw nt qld sa tas vic wa
4,3102 4,5 4,1061 1,5 2,7386 0,5 2,6575 5,244
Como um exercício que você pode cuidar de encontrar os limites de confiança de 95% usuais para as rendas médias estaduais. Para
fazer isso você poderia usar tapply () mais uma vez com o comprimento() função para encontrar os tamanhos de amostra, eo qt () funcionar
para encontrar os pontos percentuais do apropriada t-
distribuições. (Você também pode investigar as instalações do R para t- testes.)
A função tapply () também pode ser usado para lidar com a indexação mais complicada de um vetor por várias categorias.
Por exemplo, pode querer dividir os auditores fiscais tanto pelo estado e sexo. No entanto, neste caso simples (apenas um
fator) O que acontece pode ser pensado como segue. Os valores no vector são recolhidos em grupos correspondentes às
entradas distintas no fator. A função é então aplicado a cada um destes grupos individualmente. O valor é um vector de
resultados de função, marcado pela níveis atributo do fator.
A combinação de um vector e um fator de rotulagem é um exemplo do que é às vezes chamado de matriz irregular, uma vez que os
tamanhos das subclasses são possivelmente irregular. Quando os tamanhos das subclasses são todos iguais a indexação pode ser feito
implicitamente e com muito mais eficiência, como podemos ver na próxima seção.
4,3 factores ordenadas

Os níveis de factores são armazenados em ordem alfabética, ou na ordem em que foram especificadas para
fator se eles foram especificados explicitamente.
Às vezes os níveis terá uma ordenação natural que queremos gravar e queremos que a nossa análise estatística para fazer
uso. o ordenado () cria função de factores tais ordenados mas é de outro modo idêntica à fator. Na maioria dos casos, a única
diferença entre os fatores ordenados e não ordenados é que os primeiros são impressos mostrando a ordem dos níveis, mas os
contrastes gerados por eles em modelos lineares de montagem são diferentes.
18
5 matrizes e matrizes
5.1 Arrays
Uma matriz pode ser considerada como um conjunto multiplicam subscripted de entradas de dados, para o exemplo numérico. R
permite instalações simples para a criação e manipulação de matrizes, e em particular o caso especial de matrizes.
Um vector de dimensão é um vector de inteiros não negativos. Se seu comprimento é k em seguida, a matriz é
k- tridimensional, por exemplo uma matriz é uma matriz de duas dimensões. As dimensões são indexados a partir de uma até os valores indicados
no vector de dimensão.
Um vector pode ser utilizado por R como uma matriz só se dispõe de um vector de dimensão como a sua escurecer atributo. Suponhamos, por
exemplo, z é um vector de 1500 elementos. A atribuição
> dim (z) <- C (3,5,100)
dá-lhe a escurecer atributo que permite que seja tratado como uma 3 por 5 por 100 de matriz.
Outras funções, tal como matriz() e matriz () estão disponíveis para atribuições que procuram mais simples e naturais,
como veremos na Seção 5.4 [A função array ()], página 20.
Os valores do vector de dados dar os valores na matriz na mesma ordem que eles iriam ocorrer em Fortran, que é “maior
ordem da coluna”, com o primeiro subscrito mover mais rápido e mais lento o último subscrito.
Por exemplo, se o vetor de dimensão de um array, dizem uma, é c (3,4,2) em seguida, existem três × 4 ×
2 = 24 entradas em uma e o vetor de dados prende-los na ordem um [1,1,1], a [2,1,1], ..., a [2,4,2], a [3,4,2].
Os arrays podem ser unidimensional: tais matrizes são geralmente tratados da mesma maneira como vectores (incluindo durante a
impressão), mas as excepções pode causar confusão.
5.2 indexação Matriz. Subsecções de uma matriz

Os elementos individuais de uma matriz pode ser referenciada ao dar o nome da matriz seguindo-se os subscritos em
colchetes, separados por vírgulas.
Mais geralmente, subsecções de uma matriz pode ser especificado, dando uma sequência de vectores de índice
no lugar de subscritos; Contudo se qualquer posição de índice é dado um vector de índice vazio, em seguida, toda a gama de índice
que é feita.
Continuando o exemplo anterior, um [2 ,,] é um 4 × 2 matriz com dimensão vetor c (4,2) e o vector de dados que contém os
valores
c (a [2,1,1], um [2,2,1], um [2,3,1], um [2,4,1],

um [2,1,2], um [2,2,2], um [2,3,2], um [2,4,2])
naquela ordem. uma[,,] significa toda a matriz, que é o mesmo que omitindo os subscritos inteiramente e usando uma sozinho.
Para qualquer matriz, dizem Z, o vector de dimensão pode ser referenciado como explicitamente dim (Z) ( em ambos os lados de uma atribuição).
Além disso, se um nome de matriz é dado com apenas um subscrito ou vector de índice, em seguida, os valores correspondentes do vector
de dados só podem ser utilizadas; neste caso, o vector dimensão é ignorada. Este não é o caso, no entanto, se o índice único não é um vetor,
mas também uma matriz, como nós próxima discutir.
Capítulo 5: Arrays e matrizes 19
5.3 matrizes Índice

Bem como um vector de índice em qualquer posição de um índice, uma matriz pode ser utilizada com uma única matriz índice , a fim, quer
para atribuir um vector de quantidades para uma colecção irregular de elementos na matriz, ou para extrair uma colecção irregular como
um vector.
Um exemplo de matriz torna o processo transparente. No caso de uma matriz duplamente indexado, uma matriz de índice pode ser
determinado que consiste em duas colunas e tantas linhas quanto desejado. As entradas na matriz de índice são os índices de linha e
coluna para a matriz duplamente indexado. Suponha por exemplo que tem um 4 5 por matriz X e queremos fazer o seguinte:
• elementos extrato X [1,3], X [2,2] e X [3,1] como uma estrutura do vetor, e
• Substituir estas entradas na matriz X por zeros.
Neste caso, é preciso um agrupamento de 3 por 2 subscrito, como no exemplo a seguir.
> x <- matriz (01:20, dim = c (4,5)) # Gerar um 4 5 por matriz.

>x
[, 1] [, 2] [, 3] [, 4] [, 5] [1,]
1 5 9 13 17
[2], 2 6 10 14 18
[3], 3 7 11 15 19
[4,] 4 8 12 16 20
> i <- matriz (c (1: 3,3: 1), dim = c (3,2))
>i # Eu é uma matriz de índice de 3 por 2.
[, 1] [, 2] [1,]
1 3
[2], 2 2
[3], 3 1
> XI] # Extrair os elementos
[1] 9 6 3
> x [i] <- 0 # Substituir esses elementos por zeros.
>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
>
índices negativos não são permitidos em matrizes de índice. N / D e os valores de zero são permitidos: linhas na matriz índice contendo
um zero são ignorados, e linhas contendo uma N / D produzir um N / D no resultado.
Como um exemplo menos trivial, suponha que desejamos gerar uma matriz de projeto (não reduzido) para um projeto de bloco
definido por fatores blocos (b níveis) e variedades (v níveis). Suponha ainda existem n parcelas no experimento. Poderíamos proceder
da seguinte forma:
> Xb <- matriz (0, N, b)

> Xv <- matriz (0, n, v)
> ib <- cbind (1: n, blocos)
> iv <- cbind (1: n, variedades)
> Xb [ib] <- 1
> Xv [IV] <- 1
> X <- cbind (Xb, Xv)
Para construir a matriz de incidência, N digamos, poderíamos usar
> N <- crossprod (Xb, Xv)

No entanto, uma forma direta mais simples de produzir essa matriz é usar mesa():
> N <- Mesa (blocos, variedades)
matrizes de índice devem ser numérica: qualquer outra forma de matriz (por exemplo, uma matriz lógica ou carácter) fornecido como uma
matriz é tratado como um vector de indexação.
5.4 O matriz () função

Bem como dando uma estrutura de vector de um escurecer atributo, as matrizes podem ser construídos a partir de vectores pela ordem função,
que tem a forma
> Z <- matriz ( data_vector, dim_vector)
Por exemplo, se o vector h contém 24 ou menos, então o comando números
> Z <- matriz (h, dim = C (3,4,2))
usaria h para definir-se por 3 4 por 2 de matriz na Z. Se o tamanho da h é exatamente 24 o resultado é o mesmo que
> Z <- h; dim (Z) <- C (3,4,2)
No entanto, se h é menor do que 24, os seus valores são reciclados desde o início novamente para torná-lo até o tamanho 24 (ver
Secção 5.4.1 [A regra de reciclagem], página 20), mas dim (h) <- c (3,4,2) seria um sinal de um erro sobre o comprimento descasamento.
Como um exemplo extremo, mas comum
> Z <- matriz (0, C (3,4,2))
marcas Z uma matriz de todos os zeros.
Neste ponto dim (Z) representa o vetor dimensão c (3,4,2), e Z [01:24] representa o vetor de dados como era no h, e Z [] com
um índice vazio ou Z sem subscrito representa toda a matriz como uma matriz.
As matrizes podem ser usadas em expressões aritméticas e o resultado é uma matriz formada por operações elementby de elementos no
vector de dados. o escurecer atributos de operandos geralmente precisa de ser a mesma, e este transforma-se o vector de dimensão do
resultado. Então se A, B e C são todas as matrizes semelhantes, então
> D <- 2 * A * B + C + 1
marcas D uma matriz semelhante com o seu vector de dados sendo o resultado das operações de elemento-a-elemento de dados.
No entanto, a regra precisas sobre Array e Vector cálculos mistos tem de ser considerado um pouco mais de cuidado.
5.4.1 misturada vector e de matriz aritmética. A regra de reciclagem

A regra precisa afectar elemento por elemento misturado com cálculos de vectores e matrizes é um pouco subtil e difícil de
encontrar nas referências. Da experiência que temos encontrado o seguinte para ser um guia confiável.
• A expressão é digitalizada a partir da esquerda para a direita.
• Quaisquer operandos vetor curtas são estendidos através da reciclagem de seus valores até que corresponder ao tamanho de quaisquer outros operandos.
• Como vectores longas como curtas e matrizes só são encontradas, as matrizes devem ter todos a mesma
escurecer atributo ou um erro.
• Qualquer vector operando mais tempo do que um operando matriz ou matriz gera um erro.
• Se estruturas de matriz estão presentes e nenhum erro ou coacção de vector foi precipitado, o resultado é uma estrutura de
matriz com o comum escurecer atributo dos seus operandos de matriz.
5.5 O produto externo de duas matrizes

Uma operação importante em matrizes é a produto externo. E se uma e b são duas matrizes numéricas, o produto é uma matriz
exterior cujo vector de dimensão é obtida concatenando os dois vectores de dimensão (fim é importante), e cujo vector de dados é
obtido através da formação de todos os produtos possíveis de elementos do vector de dados uma com aqueles de b. O produto
externo é formado pelo operador% especiais O%:
> ab <- um% o% b
Uma alternativa é
> ab <- exterior (a, b, "*")
A função de multiplicação pode ser substituída por uma função arbitrária de duas variáveis. Por exemplo, se quiséssemos
avaliar a função f (x; y) = cos ( y) / ( 1 + X 2) sobre uma grade regular de valores com X- e y- coordenadas definido pelos vectores R X e y
respectivamente, podemos proceder da seguinte forma:
> f <- função (x, y) cos (y) / (1 + x ^ 2)

> z <- exterior (x, y, f)
Em particular, o produto externo de dois vectores comuns é uma matriz duplamente subscrito (isto é uma matriz, de
classificação, no máximo, 1). Note-se que o operador do produto exterior é, naturalmente, não comutativa. Definindo suas
próprias funções R será considerado no Capítulo 10 [Escrevendo suas próprias funções], página 42.
Um exemplo: Determinantes de 2 por 2 matrizes de único dígito

Como um exemplo artificial, mas bonito, considere os determinantes de 2 por 2 matrizes [ a, b; c, d] onde cada entrada é um número inteiro
não negativo no intervalo de 0, 1, . . . , 9, que é um dígito. O problema é encontrar os determinantes, de Anúncios - bc, de todas as matrizes
possíveis desta forma e representa a frequência com que cada valor ocorre como um alta densidade enredo. Isto equivale a encontrar a
distribuição de probabilidade do determinante se cada dígito é escolhido independentemente e uniformemente aleatoriamente.
Uma maneira elegante de fazer isso utiliza o exterior() funcionar duas vezes:
> d <- exterior (0: 9, 0: 9)

> fr <- Mesa (exterior (d, d, "-"))
> plot (fr, XLAB = "determinante", ylab = "Frequency")
Notar que enredo() aqui usa um histograma como método de parcelas, porque ele “vê” que fr é da classe " mesa". A maneira
“óbvia” de fazer este problema com para loops, a ser discutido no Capítulo 9 [Loops e execução condicional], página 40, é tão
ineficaz como para ser impraticável.
Também é talvez surpreendente que cerca de 1 em 20 destas matrizes é singular.
5,6 transposta generalizada de uma matriz

A função aperm (, uma permanente) pode ser utilizado para permutar uma matriz, uma. O argumento permanente deve ser uma
permutação dos inteiros {1, . . . , k}, Onde k é o número de índices no uma. O resultado da função é uma matriz do mesmo tamanho uma mas
com dimensão de idade dada pela perm [j] tornando-se o novo j- th dimensão. A maneira mais fácil de pensar desta operação é como
uma generalização da transposição para matrizes. De fato, se UMA é uma matriz, (isto é, uma matriz duplamente subscrito) seguida B
dado por
> B <- aperm (A, c (2,1))
é apenas a transposta de UMA. Para este caso especial de uma função simples t () está disponível, para que pudéssemos ter usado B <- t (A).
5.7 instalações Matrix

Como notado acima, uma matriz é apenas uma matriz com dois índices. No entanto, é um importante caso especial que precisa
de uma discussão em separado. R contém muitos operadores e funções que estão disponíveis apenas para matrizes. Por
exemplo t (X) é a função de transposição de matriz, como descrito acima. As funções nrow (A) e ncol (A) dar o número de linhas
e colunas na matriz UMA
respectivamente.
multiplicação 5.7.1 Matrix

O operador %*% é usada para a multiplicação de matrizes. A n por uma ou por um n matriz pode, evidentemente, ser utilizado como
um n- vetor se no contexto tal é adequado. Por outro lado, os vectores que ocorrem em expressões multiplicação de matrizes são
automaticamente promovidos tanto remar ou vetores coluna, o que for multiplicatively coerente, se possível, (embora isso nem
sempre é inequívoca possível, como veremos mais adiante).
Se, por exemplo, UMA e B são matrizes quadradas de mesmo tamanho, em seguida,
> A*B
é a matriz de elemento por elemento e produtos
> A% *% B
é o produto da matriz. E se X é um vector, em seguida
> x% *% A% *% X
é uma forma quadrática. 1
A função crossprod () Formulários “crossproducts”, significando que crossprod (X, Y) é o mesmo que t (X)% *% y mas a
operação é mais eficiente. Se o segundo argumento para crossprod ()
é omitido ele é levado para ser o mesmo que o primeiro.
O significado de diag () depende de seu argumento. diag (v), Onde v é um vector, dá uma matriz diagonal com os elementos
do vector, como os elementos da diagonal. Por outro lado diag (M),
Onde M é uma matriz, dá o vector de entradas da diagonal principal de M. Esta é a mesma convenção de que o utilizado para diag () em
Matlab. Além disso, um pouco confusa, se k é um único valor numérico então diag (k) é o k por k matriz de identidade!
5.7.2 equações lineares e inversão

Resolução de equações lineares é o inverso da multiplicação de matrizes. quando, depois de
> b <- A% *% x
só UMA e b são dadas, o vetor X é a solução de que sistema de equações lineares. Em R,
> resolver (A, b)
resolve o sistema, retornando x ( até alguma perda de precisão). Note-se que em álgebra linear, formalmente
x = A - 1 b Onde UMA - 1 denota a inverso do UMA, que pode ser calculado por
resolver (A)
mas raramente é necessário. Numericamente, é tanto ineficiente e potencialmente instável para computar x <- resolver (A)% *% b ao
invés de resolver (A, b).
A forma quadrática X T UMA - 1 X que é usado em cálculos multivariadas, deve ser calculado por algo como 2 x% *% resolver (A,
x), em vez de calcular o inverso de UMA.
1 Observe que x% *% X é ambígua, como poderia significar tanto X T X ou xx T, Onde X é a forma de coluna. em tais
casos a matriz menor parece implicitamente ser a interpretação, por isso a escalar X T X é neste caso o resultado. O Matrix xx T pode ser calculada pela cbind
(x)%% * X ou x% *% rbind (x) uma vez que o resultado de
rbind () ou cbind () é sempre uma matriz. No entanto, a melhor maneira de calcular X T X ou xx T é crossprod (x) ou x% O% x respectivamente.
2 Ainda melhor seria para formar uma raiz quadrada matriz B com A = BB T e encontrar o comprimento quadrado do
solução de por = x, talvez usando o Cholesky ou decomposição eigen de UMA.

5.7.3 Valores e vectores próprios

A função eigen (Sm) calcula os valores e vectores próprios de uma matriz simétrica
Sm. O resultado desta função é uma lista de dois componentes chamado valores e vetores. A atribuição
> ev <- eigen (SM)
irá atribuir essa lista para ev. Então ev $ val é o vector dos valores próprios de Sm e ev $ vec é a matriz de vectores prprios
correspondentes. Se tivéssemos só precisava de valores próprios poderíamos ter usado o serviço:
> evals <- eigen (SM) $ valores evals agora contém o vector de valores próprios e o segundo componente é
descartado. Se a expressão
> eigen (Sm)
é usado por si só como um comando os dois componentes são impressas, com seus nomes. Para grandes matrizes é melhor
evitar computar os vectores próprios, se eles não são necessários, utilizando a expressão
> evals <- eigen (SM, only.values = true) $ valores
5.7.4 decomposição em valores singulares e determinantes

A função SVD (H) leva um argumento de matriz arbitrária, M, e calcula a decomposição em valores singulares de M. Este é constituído por
uma matriz de colunas ortonormais você com o mesmo espaço de coluna quanto M, uma segunda matriz de colunas ortonormais V cujo
espaço coluna é o espaço de linha M e uma matriz diagonal de entradas positivas D de tal modo que M = L% *% D% *% t (V). D é
efectivamente devolvido como um vector dos elementos da diagonal. O resultado de SVD (H) é na verdade uma lista de três componentes
chamado d, u e v, com significados evidentes.
E se M é na verdade quadrado, então, não é difícil ver que
> absdetM <- prod (svd (M) $ d)
calcula o valor absoluto do determinante de M. Se este cálculo foram necessárias muitas vezes com uma variedade de matrizes
pode ser definida como uma função R
> absdet <- função (M) prod (svd (M) $ d)
após o qual nós poderíamos usar absdet () como apenas uma outra função R. Como um exemplo mais trivial, mas potencialmente útil,
você pode querer considerar escrever uma função, digamos tr (), para calcular o rastreio de uma matriz quadrada. [Dica: Você não precisa
usar um loop explícita. Olhe novamente para a diag ()
função.]
R tem uma função interna det para calcular um determinante, incluindo o sinal, e outro,
determinante, para se obter o sinal de módulo e (opcionalmente em escala logarítmica),
5.7.5 mínimos quadrados encaixe e a decomposição QR

A função lsfit () retorna uma lista dando resultados de um quadrados procedimento menos adequado. Uma atribuição tais como
> ans <- lsfit (X, Y)
dá os resultados de mínimos quadrados caber onde y é o vector de observações e X é a matriz de design. Consulte o recurso de ajuda
para obter mais detalhes, e também para a função de acompanhamento ls.diag () para, entre outras coisas, diagnósticos de regressão.
Note-se que um grande significa termo é incluído automaticamente e não precisa ser incluída explicitamente como uma coluna de X. Além
disso, note que você quase sempre vai preferir usar lm (.) ( ver Secção 11.2 [modelos lineares], página 54) para lsfit () para a modelagem
de regressão.
Outra função intimamente relacionada é qr () e seus aliados. Considere as seguintes atribuições

> Xplus <- qr (X)
> b <- qr.coef (Xplus, y)

> caber <- qr.fitted (Xplus, y)
> res <- qr.resid (Xplus, y)
Estes calcular a projecção ortogonal de y na gama de X em em forma, a projecção para o complemento ortogonal em res e o
vector de coeficiente para a projecção em b, isso é, b é essencialmente o resultado da Matlab operador 'barra invertida'.
Não é assumido que X tem posto coluna total. Despedimentos vão ser descoberto e removido como eles são encontrados.
Esta alternativa é a maneira mais antiga, de baixo nível para realizar cálculos de mínimos quadrados. Apesar de ainda ser útil em alguns
contextos, seria agora geralmente ser substituídos pelos modelos recursos estatísticos, como será discutido no Capítulo 11 [Os modelos
estatísticos em R], página 51.
5.8 formando matrizes particionadas, cbind () e rbind ()

Como já vimos informalmente, matrizes podem ser construídos a partir de outros vetores e matrizes de funções cbind () e rbind (). grosseiramente
cbind () forma matrizes por ligação em conjunto de matrizes horizontalmente, ou direcção de coluna, e rbind () verticalmente, ou
linha a linha.
Na atribuição
> X <- cbind ( arg_1, arg_2, arg_3, ...)
os argumentos para cbind () deve ser ou vectores de qualquer comprimento, ou matrizes com a mesma dimensão da coluna, que
é o mesmo número de linhas. O resultado é uma matriz com os argumentos concatenados arg 1, 2 arg, . . . formando as colunas.
Se alguns dos argumentos para cbind () são vectores que podem ser mais curtos do que o tamanho da coluna de quaisquer matrizes presentes,
caso em que eles são ciclicamente estendido para coincidir com o tamanho da coluna de matriz (ou o comprimento do vector mais longo, se não há
matrizes são dadas).
A função rbind () faz a operação correspondente para linhas. Neste caso, qualquer argumento vetor, possivelmente ciclicamente
estendida, são naturalmente tomadas como vetores de linha.
supor X1 e X2 têm o mesmo número de linhas. Para combinar estes por colunas em uma matriz X, em conjunto com uma
coluna inicial de 1 s podemos usar
> X <- cbind (1, X1, X2)
O resultado de rbind () ou cbind () sempre tem o estatuto de matriz. Conseqüentemente cbind (x) e rbind (x)
são, possivelmente, as maneiras mais simples explicitamente para permitir que o vector X a ser tratado como uma coluna ou matriz fileira, respectivamente.
5.9 A função concatenação, c (), com matrizes

Deve-se notar que, enquanto cbind () e rbind () são funções de concatenação que respeitem
escurecer atributos, o básico c () função não, mas sim limpa objetos numéricos de todos escurecer e
dimnames atributos. Este é ocasionalmente útil em sua própria direita.
A forma oficial de coagir uma série de volta a um objeto de vetor simples é usar as.vector ()
> vec <- as.vector (X)
No entanto, um resultado semelhante pode ser conseguido através da utilização c () com apenas um argumento, simplesmente para este efeito colateral:
> vec <- c (X)
Existem ligeiras diferenças entre os dois, mas, essencialmente, a escolha entre eles é em grande parte uma questão de
estilo (com o primeiro sendo preferível).
5.10 tabelas de frequência de fatores

Recorde-se que um factor define uma partição em grupos. Do mesmo modo um par de factores define uma classificação transversal em dois
sentidos, e assim por diante. A função mesa() permite tabelas de frequência a ser calculado a partir de fatores de comprimento igual. Se houver k argumentos
dos fatores, o resultado é um k- matriz maneira de frequências.
Suponhamos, por exemplo, que statef é um factor que dá o código de estado para cada entrada em um vetor de dados. A atribuição
> statefr <- Mesa (statef)
cede statefr uma tabela de frequências de cada estado na amostra. As frequências são ordenados e rotulado pela níveis atributo
do fator. Este caso simples é equivalente a, mas mais conveniente do que,
> statefr <- tapply (statef, statef, comprimento)
Suponha ainda que incomef é um factor que dá uma “classe de renda” adequadamente definido para cada entrada no vector de
dados, por exemplo, com a cortar() função:
> factor de corte ((rendimentos, quebras = 35 + 10 * (0: 7))) -> incomef
Em seguida, para calcular uma tabela de duas vias de freqüências:
> mesa (incomef, statef)

statef
incomef ato NSW nt qld sa tas vic wa
(35,45] 1 1 0 1 0 0 10
(45,55] 1 1 1 1 2 0 13
(55,65] 0 3 1 3 2 2 21
(65,75] 0 1 0 0 0 0 10
Extensão para tabelas de frequência de maior forma é imediata.

26
6 Lista e quadros de dados
6.1 Listas
uma R Lista é um objecto constituído por uma colecção de objectos ordenados conhecida como o seu componentes.
Não há necessidade particular para os componentes a ser do mesmo modo ou do tipo, e, por exemplo, uma lista poderia consistir de
um vector numérico, um valor lógico, uma matriz, um vector complexo, uma matriz de caracteres, uma função de, e em breve. Aqui está
um exemplo simples de como fazer uma lista:
> Lst <- lista (name = "Fred", esposa = "Mary", no.children = 3,

child.ages = c (4,7,9))
Os componentes são sempre numerada e pode ser sempre referido como tal. assim, se Lst é o nome de uma lista com
quatro componentes, estes podem ser referidos individualmente como Lst [[1]], lst [[2]], Lst [[3]] e Lst [[4]]. Se, além disso, Lst [[4]]
é uma matriz de vetor subscripted então
Lst [[4]] [1] é a sua primeira entrada.
E se Lst é uma lista, em seguida, a função comprimento (LST) dá o número de componentes (nível superior) que tem.
Componentes de listas também podem ser nomeado, e neste caso, o componente pode ser referido quer dando o nome do
componente como uma cadeia de caracteres no lugar do número em colchetes, ou, mais convenientemente, dando uma
expressão da forma
> nomear $ component_name
para a mesma coisa.
Esta é uma convenção muito útil, pois torna mais fácil para obter o componente certo se você esquecer o número.
Assim, no exemplo simples dado acima:
nome Lst $ é o mesmo que Lst [[1]] e é a cadeia " Fred",
Lst $ esposa é o mesmo que Lst [[2]] e é a cadeia " Maria",
Lst $ child.ages [1] é o mesmo que Lst [[4]] [1] e é o número 4.
Além disso, também se pode usar os nomes dos componentes da lista em colchetes,
isto é, Lst [[ "nome"]] é o mesmo que $ Name Lst. Isto é especialmente útil, quando o nome do componente a ser extraído é
armazenado numa outra variável como em
> x <- "nome"; Lst [[x]]
É muito importante fazer a distinção Lst [[1]] de Lst [1]. '[[...]]' é o operador usado para selecionar um único elemento, ao
passo que '[...]' é um operador geral subscripting. Assim, o primeiro é a primeiro objeto na lista Lst, e se é uma lista com o nome
o nome é não incluído. O último é um sublista da lista Lst que consiste de apenas a primeira entrada. Se for uma lista com o
nome, os nomes são transferidos para o sub-lista.
Os nomes dos componentes pode ser abreviado para baixo para o número mínimo de cartas necessários para identificá-los de forma
exclusiva. portanto Lst $ coeficientes pode ser especificada como minimamente Lst $ coe e
Lst $ covariância Como Lst $ cov.
O vector de nomes é de fato simplesmente um atributo da lista como qualquer outro e pode ser tratada como tal. Outras estruturas
além de listas podem, naturalmente, ser igualmente dada uma nomes atributo também.
Capítulo 6: Listas e quadros de dados 27
6.2 construção e modificação de listas

Novas listas podem ser formados a partir de objectos existentes, a função Lista(). Uma atribuição da forma
> Lst <- lista ( nome_1 = object_1, ..., name_m = object_m)
estabelece uma lista Lst do m componentes usando objeto 1, . . . , Objeto m para os componentes e dando-lhes nomes como especificado
pelos nomes de argumentos, (que podem ser livremente escolhidos). Se esses nomes são omitidos, os componentes só são contados.
Os componentes utilizados para formar a lista está
copiado ao formar a nova lista e os originais não são afetados.
Listas, como qualquer objecto com subscritos, pode ser prolongado através da especificação de componentes adicionais. Por exemplo
> Lst [5] <- lista (matriz = Mat)
6.2.1 listas Concatenação

Quando a função de concatenação c () é dada lista argumentos, o resultado é um objeto de lista modo também, cujos
componentes são os das listas de argumentos unidos em seqüência.
> list.ABC <- c (list.A, list.B, list.C)
Recorde-se que com objectos vetor como argumentos da função concatenação semelhante unidas entre si todos os argumentos
em uma única estrutura de vector. Neste caso todos os outros atributos, tais como
escurecer atributos, são descartados.
6.3 Os quadros de dados
UMA quadro de dados é uma lista com classe " quadro de dados". Há restrições em listas que podem ser feitas em quadros de dados, ou seja,
• Os componentes devem ser vetores (numérico, personagem ou lógicos), fatores, matrizes numéricos, listas ou outros quadros de
dados.
• Matrizes, listas e quadros de dados fornecer tantas variáveis para o novo quadro de dados como eles têm colunas, elementos
ou variáveis, respectivamente.
• vetores numéricos, logicals e fatores são incluídos como é, e por padrão 1 vetores de caracteres são coagidos a ser
fatores, cujos níveis são os valores únicos que aparecem no vector.
• estruturas vetor aparecendo como variáveis do quadro de dados devem ter todos o Mesmo comprimento,
e estruturas matriciais devem ter todos a mesma tamanho da linha.
Um quadro de dados de Maio para muitas finalidades ser considerado como uma matriz com colunas, possivelmente, de diferentes
modos e atributos. Pode ser apresentada em forma de matriz, e as suas linhas e colunas extraído utilizando as convenções de indexação
matriz.
6.3.1 Fazendo quadros de dados

Objectos que satisfaçam as restrições colocadas sobre as colunas (componentes) de um quadro de dados podem ser utilizados para formar um
utilizando a função quadro de dados:
> contadores <- data.frame (home = statef, pilhagem = rendimentos, tiro = incomef)
Uma lista cujos componentes estão em conformidade com as restrições de um quadro de dados pode ser coagidos num quadro de dados
utilizando a função as.data.frame ()
A maneira mais simples para construir um quadro de dados a partir do zero é usar o read.table () funcionar para ler um quadro
de dados inteiro de um arquivo externo. Isso é discutido no Capítulo 7 [Lendo dados de arquivos], página 30.
1 Conversão de colunas de caracteres a fatores é substituído usando o stringsAsFactors argumento para o
quadro de dados() função.

6.3.2 anexar() e separar ()

Os US $ notação, tal como contadores $ HOME, para os componentes da lista nem sempre é muito conveniente. Uma facilidade útil seria de
alguma forma para fazer os componentes de uma lista ou dados do quadro temporariamente visível como variáveis sob o seu nome do
componente, sem a necessidade de citar o nome da lista explicitamente cada vez.
o anexar() função tem um 'banco de dados', como uma lista ou quadro de dados como seu argumento. assim supõem lentilhas é uma
trama de dados com três variáveis lentilhas $ u, lentilhas $ v, lentilhas $ w. a anexar
> attach (lentilhas)
coloca o quadro de dados no caminho de procura na posição 2, e desde que não haja variáveis u, v
ou W na posição 1, u, v e W estão disponíveis como variáveis do quadro de dados em seu próprio direito. Neste ponto uma
atribuição como
> u <- v + w
não substitui o componente você do quadro de dados, mas sim mascara com outra variável
você no diretório de trabalho na posição 1 no caminho de procura. Para fazer uma mudança permanente para o próprio quadro de dados,
a maneira mais simples é recorrer mais uma vez ao $ notação:
> lentilhas $ <u - v + w
No entanto, o novo valor do componente você não é visível até que a trama de dados é destacada e ligada de novo.
Para retirar um quadro de dados, utilizar a função
> separar ()
Mais precisamente, esta declaração destaca do caminho de pesquisa da entidade atualmente na posição 2. Assim, no
presente contexto, as variáveis u, v e W haveria mais visível, exceto sob a notação lista como lentilhas $ u e assim por diante.
Entidades em posições superiores a 2 sobre o caminho de procura pode ser destacado, dando o seu número para destacar, mas
é muito mais seguro usar sempre um nome, por exemplo, separar (lentilhas) ou destacar ( "lentilhas")
Nota: Nas listas R e quadros de dados só pode ser ligado à posição 2 ou superior, e que está ligado representa
um cópia de do objeto original. Você pode alterar os valores ligados
através da atribuir, mas a lista ou dados do quadro original está inalterado.
6.3.3 Trabalhando com quadros de dados

A convenção útil que lhe permite trabalhar com muitos problemas diferentes confortavelmente juntos no diretório mesmo
trabalho é
• reunir todas as variáveis para qualquer problema bem definido e separado em uma trama de dados com um nome
adequadamente informativo;
• quando se trabalha com um problema de fixar a estrutura de dados apropriada na posição 2, e utilizar a pasta de trabalho no
nível 1 para quantidades operacionais e variáveis temporárias;
• antes de deixar um problema, adicione quaisquer variáveis que você deseja manter para o futuro referência ao quadro de dados usando o
$ forma de atribuição, e, em seguida, separar ();
• finalmente remover todas as variáveis indesejáveis do diretório de trabalho e mantê-lo o mais limpo de sobras de variáveis
temporárias quanto possível.
Desta forma, é bastante simples de trabalhar com muitos problemas no mesmo diretório, todos os que têm variáveis nomeadas
x, y e z, por exemplo.
6.3.4 Anexar listas arbitrárias

anexar() é uma função genérica que permite não somente diretórios e quadros de dados para ser anexado ao caminho de pesquisa,
mas outras classes de objeto bem. Em particular, qualquer objeto de modo " Lista"
podem ser ligados da mesma maneira:
> attach (any.old.list)
Tudo o que foi ligado pode ser retirado por destacar, pelo número da posição ou, de preferência, por nome.
6.3.5 Gerenciando o caminho de pesquisa
A função procurar mostra o caminho de pesquisa atual e assim é uma maneira muito útil para manter o controle de quais quadros
de dados e listas (e pacotes) foram anexados e imparcial. Inicialmente, ele dá
> procurar()
[1] ".GlobalEnv" "autoloads" "Pacote: base"
Onde . GlobalEnv é o espaço de trabalho. 2
Depois de lentilhas está ligado temos
> procurar()
[1] ".GlobalEnv" "lentilhas" "autoloads" "Pacote: base"
> LS (2)
[1] "u" de "v" "w"
e como vemos ls ( ou objetos) pode ser usado para examinar o conteúdo de qualquer posição no caminho de pesquisa.
Finalmente, destacamos o quadro de dados e confirme que tenha sido removido do caminho de pesquisa.
> destacar ( "lentilhas")

> procurar()
[1] ".GlobalEnv" "autoloads" "Pacote: base"
2 Consulte a ajuda on-line para autoload para o significado do segundo termo.

30
7 Dados leitura de arquivos

objetos de dados grandes costumam ser lidos como valores de arquivos externos em vez de inserido durante uma sessão de R no
teclado. instalações entrada R são simples e as suas necessidades são bastante rigoroso e até mesmo bastante inflexível. Há uma
presunção clara pelos designers de R que você será capaz de modificar seus arquivos de entrada usando outras ferramentas, como
editores de arquivos ou Perl 1 se encaixar com as exigências da R. Geralmente isso é muito simples.
Se variáveis estão a ser realizada principalmente em quadros de dados, como sugerem fortemente que deveria ser, um quadro de dados
inteiro pode ser lido diretamente com o read.table () função. Existe também uma função de entrada mais primitiva, Digitalizar (), que pode ser
chamado diretamente.
Para mais detalhes sobre como importar dados para R e também exportar dados, consulte o R Dados de importação / exportação manual.
7.1 A read.table () função

Para ler um quadro de dados inteira diretamente, o arquivo externo terá normalmente uma forma especial.
• A primeira linha do arquivo deve ter um nome para cada variável na estrutura de dados.
• Cada linha adicional do arquivo tem como primeiro item a rótulo de linha e os valores para cada variável.
Se o arquivo tem um a menos item na sua primeira linha do que em seu segundo, este arranjo é presumido estar em vigor. Assim, as primeiras
linhas de um arquivo a ser lido como um quadro de dados pode parecer como se segue.
formulário de arquivo de entrada com nomes e rótulos de linha:
Preço Chão Área quartos idade Cent.heat

01 52.00 111,0 830 5 6.2 não
02 54,75 128,0 710 5 7,5 não
03 57.50 101,0 1000 5 4,2 não
04 57.50 131,0 690 6 8,8 não
05 59.75 93,0 900 5 1,9 sim

. . .
Por itens numéricos padrão (exceto rótulos de linha) são lidos como variáveis numéricas e variáveis não-numéricos, como Cent.heat
no exemplo, como factores. Isto pode ser alterado, se necessário.
A função read.table () pode então ser usado para ler o quadro de dados directamente
> HousePrice <- read.table ( "houses.data")

Muitas vezes você vai querer omitir incluindo os rótulos de linha direta e usar as etiquetas padrão. Neste caso, o arquivo
pode omitir a coluna rótulo de linha como a seguir.
formulário de arquivo de entrada sem rótulos de linha:
Preço Chão Área quartos idade Cent.heat

52.00 111,0 830 5 6.2 não
54.75 128,0 710 5 7,5 não
57.50 101,0 1000 5 4,2 não
57.50 131,0 690 6 8,8 não
59.75 93,0 900 5 1,9 sim

. . .
1 Sob UNIX, os utilitários sed ou awk pode ser usado.

Capítulo 7: leitura de dados de arquivos 31
A trama de dados pode então ser lida

> HousePrice <- read.table ( "houses.data", header = TRUE)
onde o cabeçalho = TRUE opção especifica que a primeira linha é uma linha de títulos, e, portanto, por implicação da forma do
arquivo, que há rótulos de linha explícitos são dadas.
7.2 A Digitalizar () função

Suponhamos que os vetores de dados são de igual comprimento e são para ser lido em paralelo. Suponha ainda que existem três
vetores, o primeiro de caráter modo e os restantes dois de modo numérico, eo arquivo é input.dat. O primeiro passo é a utilização Digitalizar
() ler nos três vetores como uma lista, como se segue
> inp <- varredura ( "input.dat", lista ( "", 0,0))

O segundo argumento é uma estrutura de lista manequim que estabelece o modo dos três vectores para ser lido. O resultado,
realizada em INP, é uma lista cujos componentes são os três vetores ler. Para separar os itens de dados em três vectores
separados, utiliza atribuições como
> etiqueta <- INP [[1]]; x <- INP [[2]]; y <- inp [[3]]
Mais convenientemente, a lista manequim pode ter chamado componentes, caso em que os nomes podem ser usados para
acessar os vetores ler. Por exemplo
> inp <- varredura ( "input.dat", lista (id = "", x = 0, y = 0))
Se você deseja acessar as variáveis separadamente, eles podem tanto ser re-atribuído a variáveis no quadro de trabalho:
> etiqueta <- INP $ id; x <- INP $ x; y <- INP $ y

ou a lista pode ser ligado na posição 2 do caminho de procura (ver Secção 6.3.4 [Colocar listas arbitrárias], página 28).
Se o segundo argumento é um valor único e não uma lista, um único vector é lido, todos os componentes que devem ser do
mesmo modo que o valor fictício.
> X <- matriz (varredura ( "light.dat", 0), ncol = 5, byrow = TRUE)
Há mais elaboradas instalações de entrada disponíveis e estes são detalhados nos manuais.
7.3 Acessando conjuntos de dados embutidas
Cerca de 100 conjuntos de dados são fornecidos com R (em pacote conjuntos de dados), e outros estão disponíveis em pacotes (incluindo os
pacotes recomendados fornecidos com R). Para ver a lista de conjuntos de dados de uso atualmente disponível
dados()
Todos os conjuntos de dados fornecidos com R estão disponíveis diretamente pelo nome. No entanto, muitos pacotes ainda usam a convenção obsoleto
em que dados foi também utilizada para carregar os conjuntos de dados em R, por exemplo
dados (infert)
e este ainda pode ser utilizado com as embalagens convencionais (como neste exemplo). Na maioria dos casos, isso vai carregar um objeto R
com o mesmo nome. No entanto, em alguns casos ele carrega vários objetos, por isso consulte a ajuda on-line para o objeto para ver o que
esperar.
7.3.1 Carregando dados de outros pacotes R

Para acessar dados de um pacote em particular, use o pacote argumento, por exemplo
dados (pacote = "rpart")
de dados (puromicina, pacote = "conjuntos de dados")
Se um pacote foi anexado por biblioteca, seus conjuntos de dados são automaticamente incluídos na pesquisa.
pacotes contribuídas por usuários pode ser uma rica fonte de conjuntos de dados.
Capítulo 7: leitura de dados de arquivos 32
7,4 dados Edição

Quando invocado em um frame de dados ou matriz, editar traz um ambiente de planilha separada para edição. Isso é útil para
fazer pequenas mudanças uma vez um conjunto de dados foi lido. O comando
> xnovo <- edição (xold)
permitirá que você editar o seu conjunto de dados xold, e após a conclusão do objeto alterado é atribuído a xnovo. Se você quiser alterar o
conjunto de dados originais xold, a maneira mais simples é usar corrigir (xold),
o qual é equivalente a xold <- edição (xold).
Usar
> xnovo <- edição (data.frame ())
para inserir novos dados através da interface de planilha.

33
8 As distribuições de probabilidade
8.1 R como um conjunto de tabelas estatísticas
Um uso conveniente de R é fornecer um conjunto abrangente de quadros estatísticos. Funções são fornecidas para avaliar a
função de distribuição cumulativa P (X ≤ x), a função de densidade de probabilidade e a função quantil (dado q, o mais pequeno X
de tal modo que P (X ≤ x) > Q), e para simular a partir da distribuição.
Distribuição nome R argumentos adicionais

beta beta Shape1, shape2, NCP
binômio binom tamanho, prov
Cauchy cauchy localização, escala
qui-quadrado chisq df, NCP
exponencial exp taxa
F f DF1, df2, NCP
gama gama forma, escala
geométrico geom prov
hypergeometric hyper m, n, k
log-normal lnorm meanlog, sdlog
logística logis localização, escala
binomial negativa nbinom tamanho, prov
normal norma média, SD
Poisson pois lambda
Rank assinado signrank n
t de Student t df, NCP
uniforme UNIF mínimo máximo
Weibull weibull forma, escala

Wilcoxon Wilcox m, n
Prefixar o nome dado aqui por ' d 'Para a densidade,' p 'Para o CDF,' q 'Para a função quantil e' r 'Para simulação ( r Andom desvia).
O primeiro argumento é X para d xxx, q para p xxx, p para
q xxx e n para r xxx ( exceto por rhyper, rsignrank e rwilcox, para o qual é nn). Em não completamente todos os casos é o parâmetro de não
centralidade PCN atualmente disponíveis: consulte a ajuda on-line para mais detalhes.
o p xxx e q xxx funções todos têm argumentos lógicos lower.tail e log.p e a

d xxx os que têm registro. Isto permite, por exemplo, se o cumulativo (ou “integrado”) perigo função,
H (t) = - log (1 - F (t)), por
- p xxx ( t, ..., lower.tail = FALSE, log.p = TRUE)
ou log-probabilidades mais precisos (por d xxx (..., log = TRUE)), diretamente.
Além disso, existem funções ptukey e qtukey para a distribuição da gama de studentized de amostras a partir de uma
distribuição normal, e dmultinom e rmultinom para a distribuição multinomial. Outras distribuições estão disponíveis em pacotes
contribuíram, nomeadamente SuppDists
( https://CRAN.R-project.org/package=SuppDists).
Aqui estão alguns exemplos
> # # p-valor de 2 caudas para a distribuição t

> 2 * pt (-2,43, df = 13)
> # # limite superior de 1% para uma distribuição F (, 7 2)
> qf (0,01, 2, 7, lower.tail = FALSO)
Consulte a ajuda on-line em RNG de como a geração de números aleatórios é feito em R.

Capítulo 8: As distribuições de probabilidade 34
8.2 Análise da distribuição de um conjunto de dados

Dado um conjunto (univariada) de dados podemos examinar sua distribuição em um grande número de maneiras. O mais simples é o de
examinar os números. Dois resumos ligeiramente diferentes são dadas por resumo e
fivenum e um visor dos números haste ( um “caule e folha” parcela).
> attach (fiel)

> Resumo (erupções) Min. 1º Qu.
Mediana Significa 3ª Qu. Max.
1,600 2,163 4,000 3,488 4.454 5.100
> fivenum (erupções)
[1] 1,6000 2,1585 4,0000 4,4585 5,1000
> haste (erupções)
O ponto decimal é 1 dígito (s) para a esquerda do |
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
Uma trama caule e folhas é como um histograma, e R tem uma função hist para traçar histogramas.
> Hist (erupções)

# # fazer as caixas menores, fazer um lote de densidade
> Hist (erupções, SEQ (1,6, 5,2, 0,2), prov = TRUE)
> linhas (densidade (erupções, bw = 0,1))
> tapete (erupções) # mostrar os pontos de dados reais
plotagens de densidade mais elegantes podem ser feitas por densidade, e adicionou-se uma linha produzido pelos
densidade neste exemplo. a largura de banda bw foi escolhido por tentativa e erro como padrão dá
muito suavização (que normalmente faz para densidades “interessantes”). (Métodos melhor automatizados de escolha largura de banda
estão disponíveis, e neste exemplo bw = "SJ" dá um bom resultado.)
Histograma de erupções
0.7
0.6
0.5
0.4
Relative Frequency
0.3
0.2
0.1
0.0
1.5 2,0 2,5 3,0 3,5 4.0 4,5 5
erupções
Podemos traçar a função de distribuição cumulativa empírica usando a função ecdf.
> O gráfico (ecdf (erupções), do.points = FALSE, verticais = TRUE)
Esta distribuição é, obviamente, longe de qualquer distribuição padrão. Como sobre o modo do lado direito, dizem erupções de
mais de 3 minutos? Vamos atender a uma distribuição normal e sobrepor o CDF equipada.
> longos <- erupções [erupções> 3]

> O gráfico (ecdf (longo), do.points = FALSE, verticais = TRUE)
> x <- SEQ (3, 5,4, 0,01)
> linhas (x, pnorm (x, média = média (comprimento), dp = sqrt (var (de comprimento))), LTY = 3)
ecdf (longo)
1.0
0.8
0.6
Fn(x)
0.4
0.2
0.0
3,0 3,5 4.0 4,5 5
Quantile-quantis (qq) parcelas pode ajudar-nos a examinar mais cuidadosamente.
paridade (PTY = "s") # providenciar uma região figura quadrada

qqnorm (longo); qqline (longo)
que mostra um ajuste razoável, mas a cauda direita mais curto do que seria de esperar de uma distribuição normal. Vamos
comparar isso com alguns dados simulados de um t distribuição
Q-Q normal Plot

5.0
4.5
Sample Quantiles
4.0
3.5
3.0
-2 -1 0 1 2
Quantis teóricas
x <- r t (250, df = 5) qqnorm (x);

qqline (x)
que será normalmente (se é uma amostra aleatória) mostram caudas mais longas do que o esperado para um normal. Nós podemos fazer uma
trama QQ contra a distribuição de geração de
qqplot (qt (ppoints (250), df = 5), x, XLAB = "trama QQ para dsn t") qqline (x)
Finalmente, podemos querer um teste mais formal de acordo com normalidade (ou não). R fornece o teste de Shapiro-Wilk
> shapiro.test (longo)
teste de normalidade Shapiro-Wilk
dados: long
W = 0,9793, p = 0,01052
e o teste de Kolmogorov-Smirnov
> ks.test (longo, "pnorm", média = média (comprimento), dp = sqrt (var (de comprimento)))
Uma amostra-teste de Kolmogorov-Smirnov
dados: long
D = 0,0661, p-valor = 0,4284 hipótese alternativa:
two.sided
(Note-se que a teoria da distribuição não é válido aqui como nós estimaram os parâmetros da distribuição normal da mesma
amostra.)
Testes de 8,3 um e dois amostras

Até agora, temos comparou uma única amostra a uma distribuição normal. Uma operação muito mais comum é comparar aspectos
de duas amostras. Note-se que no R, todos os testes “clássicos”, incluindo os usados abaixo estão em pacote Estatísticas que é
normalmente carregado.
Considere os seguintes conjuntos de dados sobre o calor latente de fusão do gelo ( cal / g) de Arroz (1995, p.490)
Método A: 79,98 80,04 80,02 80,04 80,03 80,03 80,04 79,97

80,05 80,03 80,02 80,00 80,02
Método B: 80,02 79,94 79,98 79,97 79,97 80,03 79,95 79,97
Boxplots proporcionar uma comparação gráfica simples das duas amostras.
A <- digitalização ()
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 <- digitalização ()
80,02 79,94 79,98 79,97 79,97 80,03 79,95 79,97
boxplot (A, B)
o que indica que o primeiro grupo tende a dar resultados mais elevados do que o segundo.
80.04
80.02
80.00
79.98
79.96
79.94
1 2
Para testar a igualdade das médias dos dois exemplos, podemos usar uma desirmanado t- teste
> t.test (A, B)
Welch teste t de duas amostras
Dados: A e B
t = 3,2499, df = 12,027, p = 0,00694
hipótese alternativa: a verdadeira diferença entre as médias não é igual ao intervalo de confiança de 0 95
por cento:
0.01385526 0,07018320
estimativas de amostra: média de x
média de y
80,02077 79,97875
que não indicam uma diferença significativa, assumindo normalidade. Por padrão, a função de R não assume igualdade de
variâncias nas duas amostras (em contraste com o semelhante S-Plus t.test
função). Podemos usar o teste de F para testar a igualdade das variações, desde que as duas amostras são de populações
normais.
> var.test (A, B)
teste de F para comparar dois desvios

Dados: A e B
F = 0,5837, df = 12 Nm, denom df = 7, p-valor = 0,3938 hipótese alternativa: verdadeira razão de
variâncias não é igual a um intervalo de confiança de 95 por cento:
0.1251097 2,1052687
estimativas de amostra: razão
de variâncias
0.5837405
que mostra nenhuma evidência de uma diferença significativa, e por isso podemos usar o clássico t- teste que assume a igualdade de
variâncias.
> t.test (A, B, var.equal = TRUE)
T de duas amostras de teste
Dados: A e B
t = 3,4722, df = 19, p = 0,002551
hipótese alternativa: a verdadeira diferença entre as médias não é igual ao intervalo de confiança de 0 95
por cento:
0.01669058 0,06734788
estimativas de amostra: média de x
média de y
80,02077 79,97875
Todos estes testes assumir normalidade das duas amostras. O Wilcoxon (Mann-Whitney ou) de teste de duas amostras
única assume uma distribuição contínua comum sob a hipótese nula.
> wilcox.test (A, B)
teste de Wilcoxon com correção de continuidade
Dados: A e B
W = 89, valor de p = 0,007497
hipótese alternativa: a verdadeira mudança de localização não é igual a 0
Mensagem de aviso:
não pode computar p-valor exato com laços em: wilcox.test (A, B)
Observar o aviso: existem vários laços em cada uma das amostras, o que sugere fortemente que estes dados são de uma distribuição discreta
(provavelmente devido ao arredondamento).
Existem várias maneiras de comparar graficamente as duas amostras. Nós já vimos um par de boxplots. Os seguintes
> trama (ecdf (A), do.points = FALSO, verticais = VERDADEIRO, xlim = intervalo (A, B))
> plot (ecdf (B), do.points = false, verticais = TRUE, adicione = TRUE)
irá mostrar os dois CDFs empíricos, e qqplot vai realizar uma trama QQ das duas amostras. O teste de Kolmogorov-Smirnov é
da distância vertical máxima entre as duas ecdf de, assumindo uma distribuição contínua comum:
> ks.test (A, B)
De duas amostras de teste de Kolmogorov-Smirnov
Dados: A e B
D = 0,5962, p = 0,05919 hipótese alternativa: duas
faces
39
Mensagem de aviso:
não é possível calcular os valores de p correcção com laços em: ks.test (A, B)
40
9 Agrupamento, loops e execução condicional
9.1 expressões agrupados

R é uma linguagem de expressão no sentido de que o seu único tipo de comando é uma função ou expressão que retorna um
resultado. Mesmo uma atribuição é uma expressão cujo resultado é o valor atribuído, e pode ser usado sempre que pode ser
utilizado qualquer expressão; em particular várias atribuições são possíveis.
Os comandos podem ser agrupados em chaves, { expr_1; ...; expr_m}, caso em que o valor do grupo é o resultado da última
expressão no grupo avaliado. Uma vez que um tal grupo é também uma expressão pode ser, por exemplo, ser ele próprio
incluído nos parênteses e usado como parte de uma expressão ainda maior, e assim por diante.
9.2 Instruções de controle
9.2.1 Execução condicional: E se afirmações

A língua tem disponível uma construção condicional da forma
> E se ( expr_1) expr_2 outro expr_3
Onde expr 1 deve ser avaliada como um valor lógico único eo resultado de toda a expressão é então evidente.
Os “curto-circuito” operadores && e || são muitas vezes utilizados como parte da patologia em um E se
declaração. Considerando & e | aplicar elemento a elemento a vectores, && e || aplicam-se a vetores de tamanho um, e somente avaliar o
seu segundo argumento, se necessário.
Há uma versão vectorized do if / else construir, o ifelse função. Este tem a forma ifelse (condição, a, b) e retorna um vector
do mesmo comprimento que condição, com elementos um [i] E se condição [i] É verdade, caso contrário, b [i] ( Onde uma e b são
reciclados como necessário).
9.2.2 execução repetitivo: para rotações, repetir e enquanto

Há também um para construção de laçadas que tem a forma
> para ( nome em expr_1) expr_2
Onde nome é a variável de contagem. expr 1 é um vector de expressão, (muitas vezes uma sequência semelhante 01:20), e
expr 2 é muitas vezes uma expressão agrupada com suas sub-expressões escritas em termos do manequim
nome. expr 2 é repetidamente avaliada quanto nome varia através dos valores no vector de resultado
expr 1.
Como exemplo, suponha ind é um vetor de indicadores de classe e queremos produzir lotes separados de y versus X dentro
de classes. Uma possibilidade é usar coplot (), 1 qual irá produzir uma disposição de tramas correspondentes a cada nível do
factor. Outra maneira de fazer isso, agora a colocar todas as parcelas por um visor, é a seguinte:
> xc <- split (x, ind)

> yc <- split (y, ind)
> para (i no 1: comprimento (yc)) {
trama (xc [[i]], yc [[i]]) abline (lsfit (xc [[i]], yc [[i]]))}
(Note-se a função Dividido() que produz uma lista de vectores obtidos ao dividir um vector acima de acordo com as classes
especificadas por um factor. Esta é uma função útil, principalmente usado em ligação com boxplots. Veja o Socorro instalação
para mais detalhes.)
1a ser discutido mais tarde, ou utilização xyplot do pacote treliça ( https://CRAN.R-project.org/package=lattice).

Capítulo 9: Agrupamento, laços e execução condicional 41
Aviso: para() loops são usado no código R muito menos frequentemente do que em linguagens compiladas. Código que tem
uma visão 'objeto inteiro' é susceptível de ser tanto mais clara e mais rápido em R. Outras instalações looping incluir o
> repetir expr
declaração eo
> enquanto ( condição) expr
declaração.
o pausa declaração pode ser usado para encerrar qualquer loop, possivelmente de forma anormal. Esta é a única maneira de encerrar repetir
rotações.
o Próximo declaração pode ser usado para interromper um ciclo particular e pular para o “próximo”. instruções de controle são
mais frequentemente utilizados em conexão com funções que são discutidos no Capítulo 10 [escrever suas próprias funções],
página 42, e onde mais exemplos surgirão.
42
10 Escrevendo suas próprias funções
Como vimos informalmente ao longo do caminho, a linguagem R permite ao usuário criar objetos de modo função. Estes são
verdadeiros funções R que são armazenados numa forma interna especial e podem ser utilizados em outras expressões, e assim por
diante. No processo, os ganhos de linguagem enormemente no poder, conveniência e elegância, e aprender a escrever funções
úteis é uma das principais maneiras de tornar seu uso de R confortável e produtiva.
Deve-se ressaltar que a maioria das funções fornecidos como parte do sistema R, tais como significar(), var (), pós-escrito () e
assim por diante, são eles próprios escritos em R e, portanto, não diferem materialmente das funções do usuário escrito.
A função é definida por uma atribuição de forma
> nome <- função( arg_1, arg_2, ...) expressão
o expressão é uma expressão de R, (geralmente uma expressão agrupados), que utiliza os argumentos,
arg i, para calcular um valor. O valor da expressão é o valor retornado para a função.
A chamada para a função, em seguida, normalmente assume a forma nome (expr_1, expr_2, ...) e pode ocorrer em qualquer lugar uma
chamada de função é legítimo.
10.1 Exemplos simples

Como primeiro exemplo, considere uma função para calcular a duas amostras t- estatística, mostrando “todos os passos”. Este é um
exemplo artificial, é claro, uma vez que existem outras maneiras, mais simples de alcançar o mesmo fim.
A função é definida como se segue:
> twosam <- função (Y1, Y2) {

n1 <- comprimento (y1); n2 <- comprimento (Y2) YB1 <-
significativo (y1); YB2 <- média (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
Com esta função definida, você poderia executar duas amostras t- testes utilizando uma chamada tal como
> tstat <- twosam (dados $ masculino, dados $ feminino); tstat
Como um segundo exemplo, considere uma função para emular o directamente Matlab comando de barra invertida, o que
devolve os coeficientes da projecção ortogonal do vector y para o espaço de coluna da matriz, X. ( Isto é normalmente chamado de
mínimos quadrados estimativa dos coeficientes de regressão.) Este seria normalmente ser feito com o qr () função; no entanto, isso
às vezes é um pouco complicado de usar diretamente e que paga para ter uma função simples como o seguinte para usá-lo com
segurança.
Assim, um dado n por um vetor y e um n por p matriz X então X y é definido como ( X T X) - X T y,

Onde ( X T X) - é um inverso generalizado de X ' X.
> bslash <- função (x, y) {X <- QR (X)

qr.coef (x, y)}
Após este objecto é criado pode ser utilizado em frases como
> regcoeff <- bslash (Xmat, yvar)
e assim por diante.

Capítulo 10: Escrevendo suas próprias funções 43
A função R clássica lsfit () faz este trabalho muito bem, e muito mais 1. Ele, por sua vez utiliza as funções qr () e qr.coef () na
maneira um pouco contra-intuitivo acima para fazer esta parte do cálculo. Portanto, há provavelmente algum valor em ter apenas
esta parte isolada em um simples usar a função se ele vai estar em uso frequente. Se assim for, nós podemos desejar para
torná-lo um operador binário matriz para uso ainda mais conveniente.
10.2 Definindo novos operadores binários

Se tivéssemos dado o bslash () funcionar um nome diferente, a saber, uma de forma
% qualquer coisa%
que poderia ter sido usado como um operador binário em expressões em vez de na forma de funções. Suponha, por exemplo, nós
escolhemos! para o caráter interno. A definição de função, então, começar como
> "!%%" <- função (x, y) {...}
(Observe o uso de aspas.) A função poderia, então, ser usado como X%!% Y. ( O próprio símbolo de barra invertida não é uma
escolha conveniente, pois apresenta problemas especiais neste contexto.)
O operador multiplicação de matrizes,% *%, e o operador de matriz produto externo% o% são outros exemplos de
operadores binários definidos desta forma.
10.3 argumentos e padrões nomeados

Como observado pela primeira vez em Seção 2.3 [Gerar seqüências regulares], página 8, se argumentos para chamadas funções são
dadas no “ name = objecto ”Formulário, que pode ser dada em qualquer ordem. Além disso, a seqüência de argumento pode começar na
forma sem nome, posicional e especificar argumentos nomeados após os argumentos posicionais.
Assim, se há uma função fun1 definido por
> fun1 <- função (dados, data.frame, gráfico, limite) {

[Corpo função omitido]
}
em seguida, a função pode ser chamado de várias maneiras, por exemplo
> ans <- fun1 (d, df, TRUE, 20)

> ans <- fun1 (d, df, gráfico = VERDADEIRO, limite = 20)
> ans <- fun1 (dados = d, limite = 20, gráfico = VERDADEIRO, data.frame = df)
são todos equivalentes.
Em muitos casos, os argumentos podem ser dadas valores padrão comumente apropriadas, caso em que eles podem ser omitidos
por completo da chamada quando os padrões são adequados. Por exemplo, se fun1 foram definidos como
> fun1 <- função (dados, data.frame, gráfico = TRUE, limite = 20) {...}
que poderia ser chamado como
> ans <- fun1 (d, df)
que é agora equivalente para as três casos acima, ou como
> ans <- fun1 (d, df, limite = 10)
que muda de um valor predeterminado.
É importante notar que os padrões podem ser expressões arbitrárias, mesmo envolvendo outros argumentos para a mesma
função; eles não estão restritos a ser constantes como em nosso exemplo simples aqui.
1 Ver também os métodos descritos no capítulo 11 [modelos estatísticos em R], página 51

10.4 O '...' argumento

Outra exigência frequente é permitir que uma função para passar configurações argumento para outra. Por exemplo funções de
muitos gráficos usar a função par() e funciona como enredo() permitir que o usuário passar parâmetros gráficas para par() para
controlar a saída gráfica. (Veja Seção 12.4.1 [A função par ()], página 68, para mais detalhes sobre o par() função). Isso pode
ser feito através da inclusão de um argumento extra, literalmente, '...', da função, que pode então ser repassado. Um exemplo
de destaque é dado abaixo.
fun1 <- função (dados, data.frame, gráfico = TRUE, limite = 20, ...) {
[declarações omitido]
se (gráfico)
par (PCH = "*", ...)
[mais omissões]
}
Menos frequentemente, uma função será necessário referir-se a componentes de '...'. A expressão
Lista(...) avalia todos esses argumentos e retorna-los em uma lista com o nome, enquanto .. 1, ..2,
etc. avaliá-los um de cada vez, com' .. n 'Devolver o argumento inigualável n'th.
10.5 Atribuições dentro de funções

Observe que quaisquer atribuições comuns feitas dentro da função são locais e temporário e são perdidos após a saída da
função. Assim, a atribuição X <- qr (X) não afeta o valor do argumento no programa de chamada.
Para compreender completamente as regras que regem o escopo de R atribuições o leitor precisa estar familiarizado com a
noção de uma avaliação quadro, Armação. Este é um pouco avançada, embora dificilmente difícil, tópico e não é coberto ainda
mais aqui.
Se as atribuições globais e permanentes são destinados dentro de uma função, então ou o operador “superassignment”, << - ou
a função atribuir() pode ser usado. Veja o Socorro documento para obter detalhes. S-Plus os usuários devem estar cientes de que
<< - tem semânticas diferentes em R. Estes são debatidas na secção 10.7 [Scope], página 46.
10.6 Exemplos mais avançados
10.6.1 fatores de eficiência em blocos

Como um mais completo, se um pouco pedestres, exemplo de uma função, considere encontrar os fatores de eficiência para
um projeto de bloco. (Alguns aspectos deste problema já foi discutido na Seção 5.3 [matrizes Índice], página 19.)
Um projeto de bloco é definida por dois fatores, dizem blocos (b níveis) e variedades (v níveis). E se R
e K são as v por v e b por b repetições e tamanho do bloco matrizes, respectivamente, e N é o
b por v matriz de incidência, então os factores de eficiência são definidos como os valores próprios da matriz
E = I v - R - 1/2 N T K - 1 NR - 1/2 = Eu v - UMA T UMA,
Onde A = K - 1/2 NR - 1/2. Uma maneira de escrever a função é dada abaixo.
> bdeff <- função (blocos, variedades) {

blocos <- as.factor (blocos) # movimento segurança menor
b <- comprimento (níveis (blocos)) variedades <-

as.factor (variedades) # movimento segurança menor
v <- comprimento (níveis (variedades)) K <-

as.vector (tabela (blocos)) # remover attr dim
R <- as.vector (mesa (variedades)) # remover attr dim
N <- Mesa (blocos, variedades)

A <- 1 / sqrt (K) * N * rep (1 / sqrt (R), rep (b, v)) sv <- SVD (A)
lista (EFF = 1 - sv $ d ^ 2, blockcv = sv $ u, varietycv = sv $ v)}
É numericamente pouco melhor para trabalhar com a decomposição em valores singulares nesta ocasião, em vez das rotinas de
valores próprios.
O resultado da função é uma lista dando não só os factores de eficiência como o primeiro componente, mas também o
bloco e variedade contrastes canônicos, já que às vezes estes dão informação qualitativa adicional útil.
10.6.2 deixar cair todos os nomes em uma matriz impressa

Para fins de impressão com grandes matrizes ou matrizes, muitas vezes é útil para imprimi-los em forma de bloco perto sem os
nomes de matriz ou números. removendo o dimnames atributo não vai conseguir este efeito, mas sim a matriz deve ser dada uma dimnames
atributo que consiste em cadeias vazias. Por exemplo, para imprimir uma matriz, X
> Temp <- X

> dimnames (temp) <- lista (rep ( "", nrow (X)), representante ( "", ncol (X)))
> temperatura; RM (temp)
Isto pode ser muito mais convenientemente feito usando uma função, no.dimnames (), mostrado abaixo, como uma “envolvente” para
alcançar o mesmo resultado. Ele também ilustra como algumas funções de usuário eficazes e úteis podem ser bastante curto.
no.dimnames <- função (a) {

# # Remova todos os nomes de dimensão de uma matriz para impressão compacto.
d <- list () l <- 0
para (i em fraca (a)) {

d [[l <- l + 1]] <- rep ( "", i)}
dimnames (a) <- da}
Com esta função definida, uma matriz pode ser impresso em formato perto usando
> no.dimnames (X)

Isto é particularmente útil para grandes arrays de inteiros, onde os padrões são do interesse real em vez dos valores.
10.6.3 integração numérica recursiva

As funções podem ser recursivo, e pode-se definir as funções dentro de si. Note, no entanto, que tais funções, ou mesmo
variáveis, não são herdadas por chamadas funções em quadros de avaliação mais elevados, se seria se eles estavam no
caminho de pesquisa.
O exemplo abaixo demonstra uma maneira de realizar ingénuo integração numérica unidimensional. O integrando é
avaliada nos pontos finais do intervalo e no meio. Se a resposta regra trapézio de um painel é perto o suficiente para dois
painel, em seguida, o último é retornado como o valor. Caso contrário, o mesmo processo é aplicado de forma recursiva para
cada painel. O resultado é um processo de integração de adaptação que se concentra avaliações da função em regiões onde o
integrando mais afastado do linear. Há, no entanto, uma sobrecarga pesada, ea função só é competitivo com outros algoritmos
quando o integrando é suave e muito difícil de avaliar.
O exemplo também é dado, em parte, como um pequeno quebra-cabeça na programação R.
área <- função (F, a, b, eps = 1.0e-06, lim = 10) {

fun1 <- função (f, a, b, fa, fb, a0, eps, lim, divertido) {
# # função 'fun1' só é visível 'área' dentro
d <- (a + b) / 2 h <- (b -
a) / 4 FD <- f (d)
A1 <- h a2 <* (fa + fd) - H * (FD

+ fb)
if (abs (a0 - a1 - a2) <eps || == lim 0)
retorno (+ a2 a1) else {
retorno (fun (f,, um d, fa, fd, a1, eps, lim - 1, divertido) +

fun (f, d, b, fd, fb, a2, eps, lim - 1, divertido))}}
fa <- f (a) fb <- f

(b)
A0 <- ((FA + fb) * (b - a)) / 2 fun1 (f, a, b, fa, fb, a0, EPS, lim, fun1)}
10,7 Âmbito
A discussão nesta seção é um pouco mais técnico do que em outras partes deste documento. No entanto, ele detalha uma das
principais diferenças entre S-Plus e R.
Os símbolos que ocorrem no corpo de uma função pode ser divididos em três classes; parâmetros formais, variáveis locais
e variáveis livres. Os parâmetros formais de uma função são aqueles que ocorrem na lista de argumentos da função. Os seus
valores são determinados pelo processo de
obrigatório os argumentos da função reais para os parâmetros formais. As variáveis locais são aqueles cujos valores são
determinados pela avaliação de expressões no corpo das funções. Variáveis que não são parâmetros formais ou variáveis
locais são chamados de variáveis livres. variáveis livres tornam-se variáveis locais se forem atribuídos. Considere a seguinte
definição de função.
f <- função (x) {

y <- 2 * x
impressão (x) de
impressão (y) de
impressão (z)}
Nesta função, X é um parâmetro formal, y é uma variável local e z é uma variável livre. Em R as ligações variáveis livres são
resolvidos pela primeira olhando no ambiente em que a função foi criada. Isso é chamado âmbito lexical. Primeiro vamos definir
uma função chamada cubo.
cubo <- função (n) {

sq <- função () n * nn * sq ()}
a variável n na função sq não é um argumento para essa função. Por isso, é uma variável livre e as regras de escopo deve
ser usada para determinar o valor que deve ser associado a ele. Sob escopo estático ( S-Plus) o valor é o que se relaciona com
uma variável global chamada n.
Sob escopo léxico (R) é o parâmetro para a função cubo uma vez que é a ligação activa para a variável n no momento em que
a função sq foi definido. A diferença entre a avaliação em R e avaliação in S-Plus é aquele S-Plus procura uma variável global
chamada n enquanto R primeiro procura por uma variável chamada n no ambiente criado quando cubo foi invocado.
# # primeira avaliação em S
S> cubo (2)
Erro em quadrados (): objecto de "n" não encontrado
jogado S> n <- 3 S> cubo (2) [1] 18
# # em seguida, a mesma função avaliada em R

R> cubo (2) [1]
8
âmbito lexical também pode ser usado para dar funções estado mutável. No exemplo a seguir, mostramos como R pode ser
usado para imitar uma conta bancária. Uma conta bancária funcionando precisa ter um equilíbrio ou total, uma função para
fazer levantamentos, uma função para fazer depósitos e uma função para afirmar o saldo atual. Nós conseguimos isso através
da criação das três funções dentro conta e, em seguida, retornar uma lista contendo os mesmos. Quando conta é invocado que
leva um argumento numérico total e retorna uma lista contendo as três funções. Uma vez que estas funções são definidas num
ambiente que contenha total, eles terão acesso ao seu valor.
O operador de atribuição especial, << -, é usado para alterar o valor associado total.
Este operador olha para trás em ambientes que encerram para um ambiente que contém o símbolo
total e quando encontra um ambiente como esse ele substitui o valor, nesse ambiente, com o valor do lado direito. Se o
ambiente global ou de nível superior é alcançado sem encontrar o símbolo total em seguida, essa variável é criado e atribuído a
lá. Para a maioria dos usuários << - cria uma variável global e atribui o valor do lado direito a ele 2. Somente quando << - tem sido
utilizado em uma função que foi devolvido como o valor de uma outra função será o comportamento especial descrito aqui
ocorrem.
open.account <- função (total) {

Lista(
depósito = função (quantidade) {
se (quantidade <= 0)
parar ( "Depósitos deve ser positivo! \ n") no total << -
montante total +
cat (quantidade "depositado. Seu saldo é", total, "\ n \ n")},
retirar = função (quantidade) {

if (amount> total)
parar ( "Você não tem que muito dinheiro! \ n") no total << - total -
quantidade
cat (quantidade, "retirada. Seu saldo é", total, "\ n \ n")},
saldo = função () {
cat ( "Seu saldo é", total, "\ n \ n")}
)
}
ross <- open.account (100) robert <-

open.account (200)
ross $ retirar (30)
2 Em certo sentido, isso imita o comportamento em S-Plus uma vez que em S-Plus este operador sempre cria ou atribui a
uma variável global.

ross $ equilíbrio () robert $

equilíbrio ()
ross $ depósito (50) Saldo

ross $ () ross $ retirar (500)
10.8 Personalizando o ambiente

Os usuários podem personalizar o seu ambiente de várias maneiras diferentes. Há um arquivo de inicialização local e cada diretório
pode ter seu próprio arquivo de inicialização especial. funções Finalmente, o especiais
. Primeiro e. Último pode ser usado.
A localização do arquivo local de inicialização é retirado o valor do R_PROFILE variável de ambiente. Se essa variável é definida, o
arquivo Rprofile.site no subdiretório casa R etc é usado. Este arquivo deve conter os comandos que você deseja executar cada vez que
R é iniciado sob o seu sistema. A segunda,, arquivo de perfil pessoal nomeado. Rprofile 3 pode ser colocado em qualquer diretório. Se R
for chamado nesse diretório, em seguida, esse arquivo será fornecido. Este arquivo oferece aos usuários individuais controle sobre seu
espaço de trabalho e permite a diferentes procedimentos de inicialização em diferentes diretórios de trabalho. Se não . Rprofile arquivo
é encontrado no diretório de inicialização, em seguida, R procura um. Rprofile arquivo no diretório home do usuário e usa isso (se
existir). Se a variável de ambiente R_PROFILE_USER
é definido, o arquivo que aponta para é usado em vez do. Rprofile arquivos.
Qualquer função chamada. Primeiro() em qualquer um dos dois arquivos de perfil ou na. RDATA imagem tem um estatuto
especial. Ele é automaticamente realizada no início de uma sessão R e pode ser usado para inicializar o ambiente. Por
exemplo, a definição no exemplo abaixo altera o prompt para US $ e estabelece várias outras coisas úteis que podem ser
tomadas para concedido no resto da sessão.
Assim, a sequência em que os arquivos são executados é, Rprofile.site, o perfil do usuário,. RDATA
e depois . Primeiro(). A definição em arquivos posteriores irá mascarar definições em arquivos anteriores.
> . Primeiro <- function () {

Opções (prompt = "$", continue = "+ \ t") # $ é o prompt
Opções (dígitos = 5, comprimento = 999) # números personalizados e impressão
x11 () # para gráficos
par (PCH = "+") # caráter plotagem
fonte (file.path (Sys.getenv ( "HOME"), "R", "mystuff.R"))
# minhas funções pessoais
biblioteca (MASS) # anexar um pacote
}
Do mesmo modo uma função. Último(), se definiu, é (normalmente) executado no fim da sessão. Um exemplo é dado abaixo.
> . Last <- function () {graphics.off ()

# uma medida pequena de segurança.
cat (pasta (date (), "\ nAdios \ n")) # É hora para o almoço?
}
10.9 classes, funções genéricas e orientação objecto

A classe de um objeto determina como ele será tratado por aquilo que são conhecidos como genérico funções. Coloque o contrário,
uma função genérica executa uma tarefa ou ação em seus argumentos específico para a classe do próprio argumento. Se o argumento
não tem qualquer classe atributo, ou tem uma classe
3 Por isso, está escondido sob UNIX.

não atendidas especificamente pela função genérica em questão, há sempre um ação padrão
forneceu.
Um exemplo torna as coisas mais claras. O mecanismo de classe oferece ao usuário a facilidade de desenhar e escrever
funções genéricas para fins especiais. Entre as outras funções genéricas são enredo()
para a exibição de objetos graficamente, resumo () para resumir análises de vários tipos, e
ANOVA () para a comparação de modelos estatísticos.
O número de funções genéricas que pode tratar uma classe de uma maneira específica pode ser muito grande. Por exemplo, as
funções que podem acomodar em alguns objetos de moda de classe " quadro de dados"
incluir
[ [[<- qualquer as.matrix

[<- significa resumo da trama
A lista atualmente completo pode ser obtido usando a métodos() função:
> métodos (classe = "data.frame")
Por outro lado o número de classes de uma função genérica podem lidar também pode ser muito grande. Por exemplo, a enredo()
função tem um método padrão e variantes para objetos de classes
"quadro de dados", "densidade", "fator", e mais. A lista completa pode ser obtido novamente usando o métodos() função:
> métodos (trama)
Para muitas funções genéricas do corpo da função é bastante curta, por exemplo
> coef
function (object, ...) UseMethod (
"coeficiente")
A presença de UseMethod indica que esta é uma função genérica. Para ver quais métodos estão disponíveis, podemos usar métodos()
> métodos (coef) [1] *

coef.aov coef.Arima * coef.default * coef.listof *
[5] * coef.nls coef.summary.nls *
Funções não-visíveis são assinaladas por um *
Neste exemplo, existem seis métodos, nenhum dos quais pode ser visto por digitar o seu nome. Podemos ler estes por qualquer um
> getAnywhere ( "coef.aov")

Um único objeto correspondência 'coef.aov' foi encontrado Ele foi
encontrado nos seguintes locais
método S3 registrado para coeficiente de namespace Status de namespace:
estatísticas com valor
function (object, ...) {
z <- [! is.na (z)] objeto $

coeficiente z}
> getS3method ( "coeficiente", "AOV")

função (object, ...) {
z <- [! is.na (z)] objeto $

coeficiente z
50
A função chamada gen.cl será invocado pelo genérico gen para aula cl, por isso não nomear funções neste estilo salvo se
se destinam a ser métodos.
O leitor é remetido para o Definição R Idioma para uma discussão mais completa deste mecanismo.
51
11 Os modelos estatísticos em R
Esta seção presume que o leitor tem alguma familiaridade com metodologia estatística, em particular com a análise de
regressão e análise de variância. Mais tarde, fazer algumas suposições bastante mais ambicioso, ou seja, de que alguma coisa
se sabe sobre modelos lineares generalizados e regressão não linear.
Os requisitos para modelos estatísticos de montagem são suficientemente bem definida para tornar possível a construção de ferramentas
gerais que se aplicam em um amplo espectro de problemas.
R fornece um conjunto interligado de facilidades que tornam modelos estatísticos de montagem muito simples. Como
mencionamos na introdução, a saída básico é mínima, e é preciso pedir os dados chamando funções extrator.
11.1 Definindo modelos estatísticos; fórmulas

O modelo para um modelo estatístico é um modelo de regressão linear com erros independentes, homocedásticas
Σp
yi= β j X ij + e Eu, e Eu ~ NID (0, σ 2), i = 1, . . . , n
j=0
Em termos matriciais este seria escrito
y = + e Xβ
onde o y é o vector de resposta, X é o matriz modelo ou matriz de projeto e tem colunas

X 0, X 1, . . . , X p, as variáveis determinantes. Muitas vezes X 0 será uma coluna de aqueles que definem uma
interceptar prazo.
Exemplos
Antes de dar uma especificação formal, alguns exemplos podem ser úteis em definir a imagem.
supor y, x, x0, x1, x2, . . . são variáveis numéricas, X é uma matriz e UMA, B, C, . . . são factores. As seguintes fórmulas no lado esquerdo
abaixo especificam modelos estatísticos como descrito no lado direito.
y ~ xy ~ 1 + x Ambas implicam o mesmo modelo de regressão linear simples de y em x. O primeiro tem uma
termo de intercepto implícita, ea segunda uma explícita.
y ~ 0 + xy ~ -1 + xy ~ x - 1 regressão linear simples de y em X através da origem (isto é, sem uma interceptação
prazo).
log (y) ~ x1 + x2
regressão múltipla da variável transformada, log ( y), em X 1 e X 2 (com uma termo intercepção implícito).
poli y ~ (x, 2) y ~ 1 + x + I
(x ^ 2)
regressão polinomial de y em X de grau 2. A primeira forma usa polinômios ortogonais, eo segundo utiliza
poderes explícitos, como base.
y ~ X + poli (x, 2)
Regressão múltipla y com matriz modelo que consiste na matriz X , bem como em termos polinomiais X de grau
2.
Capítulo 11: Os modelos estatísticos em R 52
y~A análise de classificação único de modelo variância y, com as classes determinadas pela UMA.
y ~ A + x análise de classificação única do modelo de covariância y, com as classes determinadas pela

UMA, e com covariável x.
y~A*B
y ~ A + B + A: B Y ~
B% na% A y ~ A / B
modelo de dois fatores não aditiva de y em UMA e B. Os dois primeiros especificar a mesma classificação cruzados e o
segundo dois especificar a mesma classificação aninhada. Em termos abstratos todos os quatro especificar o mesmo
modelo subespaço.
y ~ (A + B + C) ^ 2 y ~ A *
B * C - A: B: C
Três experimento factor, mas com um modelo contendo os efeitos principais e duas interacções único factor. Ambas
as fórmulas especificar o mesmo modelo.
y ~ A * xy ~
A/X
y ~ A / (1 + x) - 1
modelos lineares simples separados de regressão de y em X dentro dos níveis de UMA, com diferentes codificações. A
última forma produz estimativas explícitas de como muitos intercepta e inclinações diferentes, pois há níveis em UMA.
y ~ A * B + Erro (C)
Uma experiência com dois factores de tratamento, UMA e B, e erro estratos determinada pelo factor C. Por exemplo, um
experimento de separação, com parcelas inteiras (e portanto também subparcela), determinado pelo factor C.
O operador ~ é utilizado para definir um fórmula modelo em R. A forma, por um modelo linear comum, é
resposta ~ op_1 term_1 op_2 term_2 op_3 term_3 ...

Onde
resposta é um vector ou matriz, (ou expressão avaliando a um vector ou matriz) que define a variável (s) resposta.
op i é um operador, tanto + ou -, o que implica a inclusão ou exclusão de um termo no modelo, (o primeiro é

opcional).
i prazo é também
• um vector de expressão ou de matriz, ou 1,
• um factor, ou
• uma expressão da fórmula que consiste de factores, vectores ou matrizes ligadas por
operadores de fórmula.
Em todos os casos cada termo define um conjunto de colunas, quer para ser adicionado ou removido a partir da
matriz modelo. UMA 1 significa uma coluna de intercepção e é incluído por defeito na matriz modelo, a menos que
explicitamente removido. o operadores de fórmulas são semelhantes em vigor para a notação Wilkinson e Rogers usado
por programas como Glim e Genstat. Uma mudança inevitável é que o operador '' torna-se ':' desde o período é um
personagem nome válido em R.
A notação é resumido abaixo (com base na Chambers & Hastie, 1992, p.29):
Y~M Y é modelado como M.
M_1 + m_2 Incluir M 1 e H 2.

M_1 - m_2 Incluir M 1 deixando de fora termos de H 2.
M_1: m_2 O produto de tensor M 1 e H 2. Se ambos os termos são fatores, então o “subclasses”
fator.
M_1% em% m_2

Igual a M_1: m_2, mas com uma codificação diferente.
M_1 * M_2 M_1 + m_2 + M_1: m_2.
M_1 / M_2 M_1 + m_2% em% M_1.
M^n Todos os termos em M juntamente com “interações” até ao fim n
EU( H) Isolar M. Dentro M todos os operadores têm o seu significado aritmética normal, e esse termo aparece na matriz
modelo.
Note-se que dentro dos parênteses que normalmente encerram argumentos da função todos os operadores têm o seu significado
aritmética normal. A função EU() é uma função de identificação utilizado para permitir termos em fórmulas modelo a ser definido utilizando
operadores aritméticos.
Nota particularmente que as fórmulas modelo especificar o colunas da matriz do modelo, a especificação dos parâmetros
estar implícita. Este não é o caso em outros contextos, por exemplo, na especificação de modelos não lineares.
11.1.1 Contrastes
Precisamos de pelo menos alguma idéia de como as fórmulas modelo especificar as colunas da matriz modelo. Isso é fácil se
tivermos variáveis contínuas, como cada um fornece uma coluna da matriz modelo (e a intercepção irá fornecer uma coluna de
uns se incluídos no modelo).
Que tal um k- fator de nível UMA? A resposta é diferente para fatores sem ordem e ordenada. Para
não ordenado fatores k - 1 colunas são gerados para os indicadores do segundo,. . . , k th níveis do fator. (Assim, a
parametrização é implícito ao contrário, a resposta a cada nível com que na primeira.) Para pedido factores a k - 1 colunas são
os polinómios ortogonais sobre
1, . . . , k, omitindo o termo constante.
Embora a resposta já é complicado, não é toda a história. Em primeiro lugar, se a intercepção está omitida em um modelo que
contém um factor de termo, o primeiro como o termo é codificado em k colunas dando os indicadores para todos os níveis. Em
segundo lugar, todo o comportamento pode ser alterado pela
opções configuração para contrastes. A configuração padrão em R é
Opções (contrastes = c ( "contr.treatment", "contr.poly"))
A principal razão para mencionar isto é que R e S têm diferentes padrões para factores não ordenadas, S utilizando Helmert
contrasta. Então, se você precisa comparar seus resultados com os de um livro ou de papel que costumava S-Plus, você precisará
definir
Opções (contrastes = c ( "contr.helmert", "contr.poly"))
Esta é uma diferença deliberada, como contrastes de tratamento (padrão do R) são pensados mais fácil para os recém-chegados de interpretar.
Nós ainda não ter terminado, como o esquema de contraste a ser utilizado pode ser definido para cada termo no modelo usando as
funções contrastes e C.
Nós ainda não ter considerado termos de interação: geram os produtos das colunas introduzidas para os seus termos de
componentes.
Embora os detalhes são complicadas, fórmulas modelo em R será normalmente gerar os modelos que um estatístico perito seria de
esperar, desde que a marginalidade é preservada. Encaixe, por exemplo, um modelo com uma interacção mas não os efeitos principais
correspondentes conduzirá em geral para os resultados surpreendentes, e é apenas para os especialistas.
11.2 modelos lineares

A função básica para vários modelos comuns de montagem é lm (), e uma versão simplificada da chamada é a seguinte:
> fitted.model <- lm ( Fórmula, dados = quadro de dados)
Por exemplo
> FM2 <- lm (y ~ x1 x2 +, dados de produção =)
caberia um modelo de regressão múltipla de y em X 1 e X 2 (com implícito intercepto).
O parâmetro importante (mas tecnicamente opcional) Dados = produção especifica que todas as variáveis necessárias para
construir o modelo deve vir em primeiro lugar a partir da Produção quadro de dados. Este é o caso, independentemente de quadro
de dados Produção foi anexado no caminho de procura ou não.
11.3 funções genéricas para extrair informações do modelo

O valor de lm () é um objecto modelo ajustado; tecnicamente uma lista de resultados da classe " lm". Informações sobre o modelo
ajustado pode então ser exibido, extraído, plotados e assim por diante usando funções genéricas que se orientam para objetos da
classe " lm". Esses incluem
add1 fórmula desvio prever etapa

drop1 apelido capa impressão resumo
efeitos ANOVA etiquetas proj vcov
coef família enredo resíduos
Uma breve descrição dos mais utilizados é dada abaixo.
anova ( object_1, object_2)

Comparar um submodelo com um modelo exterior e produzir uma análise da tabela de variância.
coef ( objeto)
Extrair o coeficiente de regressão (matriz). Forma longa: coeficientes
( objeto).
desvio( objeto)
soma dos quadrados dos resíduos, ponderada se for o caso.
Fórmula( objeto)
Extrai-se a fórmula modelo.
enredo( objeto)
Produzir quatro parcelas, mostrando resíduos, valores embutidos e alguns diagnósticos.
prever( objeto, newdata = quadro de dados)

O quadro de dados fornecidos devem ter variáveis especificadas com os mesmos rótulos como o original. O valor é um
vector ou uma matriz de valores previstos correspondentes aos valores das variáveis determinantes quadro de dados.
impressão( objeto)
Imprimir uma versão concisa do objeto. Na maioria das vezes usado de forma implícita.
resíduos ( objeto)
Extrai-se a (matriz de) resíduos, ponderação apropriado. Forma curta: resid ( objeto).
degrau( objeto)
Escolha um modelo adequado, adicionando ou caindo termos e preservar hierarquias. O modelo com o menor
valor de AIC (Um Critério de Informação de Akaike) descobriu na busca por etapas é retornado.
resumo ( objeto)
Imprimir um resumo abrangente dos resultados da análise de regressão.
vcov ( objeto)
Retorna a matriz de variância-covariância dos principais parâmetros de um objeto modelo ajustado.
11.4 Análise de comparação variância e modelo

A função de encaixe modelo AOV ( Fórmula, dados = quadro de dados) opera no nível mais simples de uma forma muito semelhante
à função lm (), ea maioria das funções genéricas listados na tabela na Seção de 11,3 [funções genéricas para extrair informações
do modelo], página 54, se aplicam.
Note-se que, além AOV () permite uma análise de modelos com múltiplas camadas de erro, como experimentos parcela
subdividida, ou blocos incompletos equilibrados com recuperação de informações inter-bloco. A fórmula modelo
resposta ~ mean.formula + Erro( strata.formula)

especifica uma expericia multi-camada com camadas de erro definida pela strata.formula. No caso mais simples, strata.formula é
simplesmente um factor de, quando se define um experimento duas camadas, ou seja, entre e dentro dos níveis do factor.
Por exemplo, com todos os factores variáveis que determinam, uma fórmula modelo tal como em que:
> fm <- AOV (rendimento ~ v + n * p * k + erro (fazendas / blocos), dados = farm.data)
iria tipicamente ser usado para descrever uma experiência com o modelo significativo v + n * p * k e três estratos de erro, ou seja,
“entre quintas”, “em Farms, entre os blocos” e “dentro de blocos”.
tabelas 11.4.1 ANOVA

Note-se também que a análise da tabela de variância (ou tabelas) são para uma sequência de modelos embutidos. As somas dos
quadrados mostrados são a redução nas soma de quadrados residuais resultantes de uma inclusão de esse termo no modelo de aquele
lugar na sequência. Portanto, apenas para fins experimentais ortogonais será da ordem de inclusão ser inconsequentes.
Para as experiências de multiextratado o procedimento é primeiro a projectar a resposta para os estratos de erro, mais uma vez em
sequência, e para ajustar o modelo média para cada projecção. Para mais detalhes, veja Chambers & Hastie (1992).
Uma alternativa mais flexível para a tabela ANOVA padrão completo é comparar dois ou mais modelos directamente usando o ANOVA
() função.
> anova ( fitted.model.1, fitted.model.2, ...)
A tela é em seguida uma tabela ANOVA que mostra as diferenças entre os modelos ajustados quando montados em
sequência. Os modelos ajustados a serem comparadas será normalmente uma sequência hierárquica, de curso. Isso não dá
informações diferentes para o padrão, mas torna mais fácil de compreender e controle.
11,5 Actualizar equipado modelos

o atualizar() é função, em grande parte uma função conveniente que permite que um modelo para ser instalada de forma que difere de um previamente
montados normalmente por apenas alguns termos adicionais ou removidos. Sua forma é
> new.model <- atualizar( old.model, nova fórmula)
No nova fórmula o nome especial constituído por um período, '', somente, pode ser usado para significar ‘a parte
correspondente da velha fórmula modelo’. Por exemplo,
> fm05 <- lm (y ~ x1 + x2 + x3 + x4 + x5, dados de produção =)

> FM6 <- atualização (fm05, ~ + x6..)
> smf6 <- atualização (. FM6, sqrt () ~.)
caberia uma regressão múltipla cinco variate com variáveis (presumivelmente) a partir do quadro de dados
Produção, ajustar um modelo adicional incluindo uma variável regressor sexto, e encaixar uma variante do modelo onde a resposta
tinha uma raiz quadrada transformação aplicada.
Note-se especialmente que, se o dados = argumento é especificado na chamada original para a função de encaixe modelo, esta
informação é passada através do objeto modelo ajustado para atualizar() e seus aliados.
O nome '.' Também pode ser usado em outros contextos, mas com significado ligeiramente diferente. Por exemplo
> fmfull <- lm (. y ~, dados de produção =)
caberia um modelo com resposta y e variáveis regressoras todas as outras variáveis no quadro de dados
Produção.
Outras funções para explorar seqüências incrementais de modelos são add1 (), drop1 () e
degrau(). Os nomes destes dar uma boa pista para o seu propósito, mas para mais detalhes consulte a ajuda on-line.
11.6 modelos lineares generalizados

modelagem linear generalizado é um desenvolvimento de modelos lineares para acomodar as duas distribuições e
transformações de resposta não-normal de linearidade de um modo limpo e simples. Um modelo linear generalizado pode ser
descrita em termos da seguinte sequência de suposições:
• Há uma resposta, y, de variáveis de interesse e estímulo X 1, X 2, . . . , cujos valores influenciam a distribuição da resposta.
• As variáveis de estímulo influenciar a distribuição de y através uma única função linear, somente.
Esta função linear é chamado de preditor linear, e é geralmente escrito
η = β 1 X 1 + β 2 X 2 + · · · + β p X p,
conseqüentemente X Eu não tem influência sobre a distribuição de y se e apenas se β i = 0.
• A distribuição de y é a forma de
[ Um φ {yλ (μ) - γ (λ (μ))} + Τ (y, φ) ]

f Y ( y; μ, φ) = exp
Onde φ é um parâmetro de escala ( possivelmente conhecido), e é constante para todas as observações, UMA
representa um peso antes, supõe conhecido mas, possivelmente, variando de acordo com as observações, e
μ é a média de y. Assim, presume-se que a distribuição de y é determinada por sua média e, eventualmente, um parâmetro de
escala bem.
• O significativo, μ, é uma função invertível suave do preditor linear:
= μ m (η), η = m - 1 ( μ) = `(μ)
e esta função inversa, '(), é chamado o função de ligação.
Estes pressupostos estão soltos o suficiente para abranger uma ampla classe de modelos úteis na prática estatística, mas firme o
suficiente para permitir o desenvolvimento de uma metodologia unificada de estimação e inferência, pelo menos aproximadamente. O
leitor é remetido para qualquer uma das obras de referência atuais sobre o assunto para mais detalhes, tais como McCullagh & Nelder
(1989) ou Dobson (1990).
11.6.1 Famílias
A classe dos modelos lineares generalizados tratado por instalações fornecidos em R inclui gaussian, binomial, poisson, gaussiana
inversa e gama distribuições de resposta e também quasi-likelihood
modelos em que a distribuição de resposta não é explicitamente especificados. Neste último caso, o função de variância deve ser
especificada como uma função da média, mas em outros casos, esta função é implicado pela distribuição resposta.
Cada distribuição resposta admite uma variedade de funções de ligação para conectar a média com o preditor linear. Aqueles
automaticamente disponíveis são mostrados na tabela a seguir:
Sobrenome funções de ligação
binômio logit, probit, registro, cloglog

gaussian identidade, log, inversa
Gama identidade, inversa, log
inverse.gaussian 1 / mu ^ 2, identidade, inversa, de log
poisson identidade, registro, sqrt
quase logit, probit, cloglog, identidade, inversa, log, 1 / mu ^ 2, sqrt
A combinação de uma distribuição de resposta, uma função de ligação e vários outros pedaços de informação que são
necessários para realizar o exercício de modelagem é chamado de família do modelo linear generalizado.
11.6.2 O GLM () função

Como a distribuição da resposta depende das variáveis de estímulo através de uma única função linear só, o mesmo mecanismo
que foi usado para modelos lineares pode ainda ser utilizado para indicar a parte linear de um modelo generalizado. A família tem
de ser especificado de um modo diferente.
A função de R para ajustar um modelo linear generalizado é GLM () o qual usa o formulário
> fitted.model <- glm ( Fórmula, família = family.generator, dados = quadro de dados)
A única novidade é o family.generator, que é o instrumento pelo qual a família está descrito. É o nome de uma função que
gera uma lista de funções e expressões que, juntos, definir e controlar o processo de modelo e estimativa. Embora isso possa
parecer um pouco complicado à primeira vista, o seu uso é bastante simples.
Os nomes da norma, geradores família fornecidas são dadas em “Nome de Família” na tabela na Seção 11.6.1 [famílias],
página 57. Onde há uma escolha de links, o nome do link pode também ser fornecido com o nome de família, em parênteses
como um parâmetro. No caso do quase família, a função de variância também pode ser especificado desta maneira.
Alguns exemplos tornar o processo transparente.
o gaussian família
Uma chamada tais como
> fm <- glm (y ~ x1 + x2, família = gaussian, dados = vendas)
obtém o mesmo resultado quanto
> fm <- lm (y ~ x1 + x2, dados = vendas)
mas muito menos eficiente. Note como a família gaussiana não é fornecida automaticamente com uma escolha de links, de modo
nenhum parâmetro é permitido. Se um problema requer uma família gaussiana com um link fora do padrão, isso geralmente pode ser
alcançado através da quase família, como veremos mais tarde.
o binômio família
Considere-se uma pequena exemplo, artificial, de Silvey (1970).
Na ilha do mar Egeu da Kalythos os habitantes do sexo masculino sofrem de uma doença ocular congênita, cujos efeitos se tornam
mais acentuada com o aumento da idade. As amostras de machos insular de várias idades foram testados para a cegueira e os
resultados registados. Os dados são mostrados abaixo:
Era: 20 35 45 55 70
No. testados: 50 50 50 50 50
Não cego: 6 17 26 37 44
O problema que considerar é para caber ambos os modelos logísticos e probit a esses dados e estimar para cada modelo do DL50,
que é a idade em que a chance de cegueira por um habitante do sexo masculino é de 50%.
E se y é o número de cegos na idade X e n o número testado, ambos os modelos têm a forma
y ~ B ( n, F (β 0 + β 1 x))
onde para o caso probit, F (z) = Φ ( z) é a função de distribuição normal padrão, e no caso logit (o padrão), F (z) = E z / ( 1 + e z). Em
ambos os casos, a DL50 é
DL50 = - β 0 / β 1
isto é, o ponto no qual o argumento da função de distribuição é zero.
O primeiro passo é para definir os dados acima como uma estrutura de dados
> kalythos <- data.frame (X = C (20,35,45,55,70), n = REP (50,5),

y = c (6,17,26,37,44))
Para ajustar um modelo binomial usando GLM () existem três possibilidades de resposta:
• Se a resposta é um vetor presume-se para segurar binário dados, e assim deve ser um vetor 0/1.
• Se a resposta é um matriz de duas colunas presume-se que a primeira coluna contém o número de sucessos para o
ensaio e a segunda contém o número de falhas.
• Se a resposta é um fator, seu primeiro nível é tomado como falha (0) e todos os outros níveis como 'sucesso' (1).
Aqui temos a segunda destas convenções, então adicionamos uma matriz para a nossa estrutura de dados:
> kalythos $ Ymat <- cbind (kalythos $ y, kalythos $ n - kalythos $ y)
Para ajustar os modelos que usamos
> fmp <- glm (Ymat ~ x, família = binomial (link = probit), data = kalythos)
> fml <- GLM (Ymat ~ x, família = binomial, dados = kalythos)
Desde o link logit é o padrão, o parâmetro pode ser omitido na segunda chamada. Para ver os resultados de cada caber
poderíamos usar
> Resumo (FMP)

> Resumo (fml)
Ambos os modelos se encaixam (muito) bem. Para encontrar a estimativa DL50 podemos usar uma função simples:
> LD50 <- função (b) -b [1] / b [2]

> LDP <- DL50 (coef (FMP)); LDL <- DL50 (coef (FML)); c (LDP, LDL)
As estimativas reais de esses dados são 43.663 anos e 43.601 anos, respectivamente.
modelos de Poisson
Com a família Poisson o link padrão é o registro, e na prática, o principal uso desta família é para caber modelos log-linear de
Poisson substituto para dados de frequência, cuja distribuição real é muitas vezes multinomial. Este é um assunto grande e
importante que não vamos discutir mais aqui. Ele ainda constitui uma parte importante do uso de modelos generalizados
não-gaussianas gerais.
Ocasionalmente, os dados de Poisson genuinamente surge na prática e, no passado, foi muitas vezes analisadas como dados gaussianas
após tanto um registo ou uma transformação de raiz quadrada. Como uma alternativa elegante para este último, um modelo linear de Poisson
generalizada pode ser equipado como no exemplo a seguir:
> fmod <- GLM (y ~ A + B + x, família = Poisson (link = sqrt),

Dados = worm.counts)
modelos quasi-likelihood
Para todas as famílias a variância da resposta dependerá da média e vai ter o parâmetro de escala como um multiplicador. A
forma de dependência da variância na média é uma característica da distribuição de resposta; por exemplo, para a distribuição
de Poisson Var [ Y] = μ.
Para a estimativa quase probabilidade e inferência a distribuição resposta precisa não é especificado, mas sim apenas uma
função de ligação e a forma da função de variação, uma vez que depende da média. Desde estimativa de quasi-verossimilhança
usa formalmente técnicas idênticas às da distribuição de Gauss, esta família fornece uma maneira de modelos de gaussianas de
montagem, com funções de ligação não-padrão ou funções de variância, aliás.
Por exemplo, considere a montagem da regressão não-linear
y = θ1 z1 + e
z2- θ2
o qual pode ser escrito como alternativamente
1
y= + e
β1 X1+ β2 X2
Onde X 1 = z 2 / z 1, X 2 = - 1 / z 1, β 1 = 1 / θ 1 e β 2 = θ 2 / θ 1. Supondo que um quadro de dados adequado para ser configurado que poderiam caber esta
regressão não-linear como
> nlfit <- GLM (y ~ x1 + x2 - 1,

família = quasi (= ligação inversa, variância = constante), os dados =
Biochem)
O leitor é remetido para o manual e o documento de ajuda para obter mais informações, conforme necessário.
11.7 mínimos quadrados não-lineares e modelos de probabilidade máxima

Certas formas de modelo não-linear pode ser montada por Modelos Lineares Generalizados ( GLM ()). Mas na maioria dos casos, temos
de abordar o problema de ajuste de curva não linear como um dos otimização não-linear. rotinas de otimização não-linear de R são optim
(), NLM () e nlminb (), que fornecem a funcionalidade (e mais) de S-Plus 's Senhora() e nlminb (). Buscamos os valores dos parâmetros
que minimizam a algum índice de falta de ajustamento, e eles fazem isso por experimentar vários valores de parâmetro de forma
iterativa. Ao contrário de regressão linear, por exemplo, não há garantia de que o procedimento irá convergir em estimativas
satisfatórios. Todos os métodos requerem estimativas iniciais sobre o que os valores dos parâmetros para tentar, e de convergência
pode depender criticamente sobre a qualidade dos valores iniciais.
11.7.1 mínimos quadrados

Uma maneira de ajustar um modelo não-linear é, minimizando a soma dos erros quadrados (SSE) ou resíduos. Este método faz
sentido se os erros observados poderia ter plausivelmente surgido a partir de uma distribuição normal.
Aqui está um exemplo de Bates & Watts (1988), página 51. Os dados são:
> x <- c (0,02, 0,02, 0,06, 0,06, 0,11, 0,11, 0,22, 0,22, 0,56, 0,56,
1,10, 1,10)
> y <- c (76, 47, 97, 107, 123, 139, 159, 152, 191, 201, 207, 200)
O critério de ajuste a ser minimizada é:
> fn <- função (p) soma ((y - (P [1] * x) / (p [2] + x)) ^ 2)
Para fazer o ajuste precisamos estimativas iniciais dos parâmetros. Uma maneira de encontrar valores iniciais sensatas é
plotar os dados, acho que alguns valores de parâmetro, e sobrepor a curva modelo usando esses valores.
> trama (x, y)

> xfit <- seq (0,02, 1,1, 0,05)
> yfit <- 200 * xfit / (0,1 + xfit)
> linhas (spline (xfit, yfit))
Nós poderíamos fazer melhor, mas esses valores iniciais de 200 e 0,1 parece adequado. Agora faça o ajuste:
> a <- nlm (fn, p = c (200, 0,1), de juta = TRUE)
Após a montagem, out $ mínimo é o SSE, e $ Estimativa para fora são os quadrados estimativas menos dos parâmetros.
Para obter os erros padrão aproximados (SE) das estimativas que fazemos:
> sqrt (diag (2 * fora $ mínimo / (comprimento (y) - 2) * resolver (fora $ hessian)))
o 2 que é subtraído na linha acima representa o número de parâmetros. Um intervalo de confiança de 95% seria a
estimativa do parâmetro ± 1,96 SE. Nós podemos sobrepor os mínimos quadrados caber em um novo lote:
> trama (x, y)

> xfit <- seq (0,02, 1,1, 0,05)
> yfit <- 212.68384222 * xfit / (0.06412146 + xfit)
> linhas (spline (xfit, yfit))
O pacote padrão Estatísticas oferece muito mais extensas instalações para modelos não lineares de ajuste por mínimos quadrados. O
modelo que acabamos equipado é o modelo de Michaelis-Menten, para que possamos usá
> df <- data.frame (x = x, y = y)

> caber <- nls (y ~ SSmicmen (x, Vm, K), gl)
> ajuste
modelo de regressão não-linear

modelo: y ~ SSmicmen (x, Vm, K) dados: df
vm K
212.68370711 0.06412123 residual soma de quadrados:
1195.449
> Resumo (ajuste)
Fórmula: y ~ SSmicmen (x, Vm, K)
parâmetros:
Estimativa Std. valor de erro t 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
Residual erro padrão: 10,93 em 10 graus de liberdade
Correlação de estimativas de parâmetros:

Vm
K 0,7651
11.7.2 probabilidade máxima

máxima verossimilhança é um método de ajuste do modelo não-linear que se aplica mesmo que os erros não são normais. O método localiza
os valores dos parâmetros que maximizam a probabilidade de log, ou equivalentemente que minimizem a probabilidade de log-negativo. Aqui
é um exemplo de Dobson (1990), pp. 108-111. Este exemplo se ajusta a um modelo logístico de dose-resposta os dados, os quais também,
claramente, podia ser se encaixam pela GLM (). Os dados são:
> 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)
O log-probabilidade negativa para minimizar é:
> fn <- função (p)

soma (- (y * (P [1] + P [2] * x) - N * log (1 + exp (P [1] + P [2] * x))
+ log (escolher (n, y))))
Nós escolhemos valores iniciais sensatas e fazer o ajuste:
> a <- NLM (fn, p = c (-50,20), hessian = TRUE)
Após a montagem, out $ mínimo é o log-probabilidade negativo, e $ Estimativa para fora são as estimativas de máxima
verossimilhança dos parâmetros. Para obter os SEs aproximadas das estimativas que fazemos:
> sqrt (diag (resolver (fora $ hessian)))
Um intervalo de confiança de 95% seria a estimativa do parâmetro ± 1,96 SE.
11.8 Alguns modelos não-padrão

Concluímos este capítulo com apenas uma breve menção de alguns dos outros serviços disponíveis em R para problemas de regressão e
de análise de dados especiais.
• modelos mistos. o recomendado nlme ( https://CRAN.R-project.org/package=nlme)

pacote fornece funções LME () e nlme () para modelos de efeitos mistos lineares e não-lineares, que é regressões
lineares e não-lineares no qual alguns dos coeficientes correspondem a efeitos aleatórios. Essas funções fazem uso
pesado de fórmulas para especificar os modelos.
• regressões aproximam locais. o loess () função ajusta uma regressão não paramétrica, utilizando uma regressão ponderada localmente.
Tais regressões são úteis para realçar uma tendência nos dados desorganizados ou para a redução de dados para dar algum
conhecimento sobre um grande conjunto de dados. Função loesse é no pacote standard Estatísticas, juntamente com o código para a
regressão projeção perseguição.
• regressão robusta. Existem várias funções disponíveis para os modelos de regressão de ajuste em uma maneira
resistente à influência de outliers extremos nos dados. Função lqs no pacote recomendado MASSA ( https://CRAN.R-project.org/package=MA
fornece algoritmos stateof na arte para se encaixa altamente resistentes. Métodos menos resistentes, mas
estatisticamente mais eficiente estão disponíveis em embalagens, por exemplo função rlm no pacote MASSA ( https: //
CRAN.R-project.org/package=MASS).
• modelos aditivos. Esta técnica tem como objectivo a construção de uma função de regressão a partir de funções aditivas
lisas das variáveis que determinam, normalmente um para cada variável determinante. Funções AVAS e ás no pacote acepack
( https://CRAN.R-project.org/package=acepack)
e funções bruto e marte no pacote mda ( https: / / CRAN. projeto R-. org / pacote = mda) fornecer alguns exemplos dessas
técnicas em pacotes de contribuições dos usuários para
R. Uma extensão é Generalizadas modelos aditivos, implementado em pacotes de contribuições dos usuários gam ( https://CRAN.R-project.o
e mgcv ( https: // CRAN. R-project.org/package=mgcv).
• modelos Tree-base. Em vez de procurar um modelo linear mundial explícita para previsão ou interpretação, os modelos baseados em
árvore procuram bifurcam os dados, de forma recursiva, em pontos críticos das variáveis que determinam a fim de dividir os dados
em última análise em grupos que são tão homogéneo quanto possível no interior, e como heterogéneos quanto possível entre. Os
resultados levam frequentemente a insights que outros métodos de análise de dados tendem a não produzir. Os modelos são
novamente especificado no formulário modelo linear comum. A função de encaixe do modelo é
árvore(), mas muitas outras funções genéricas como enredo() e texto() são bem adaptados para exibir os resultados de um
baseado em árvore ajuste do modelo de forma gráfica. modelos de árvore estão disponíveis em R através da os pacotes de
contribuições dos usuários rpart ( https: / / CRAN. projeto R-. org / pacote = rpart) e árvore ( https: / / CRAN. projeto R-. org /
package = árvore).
63
12 procedimentos gráficas
instalações gráficas são um componente importante e extremamente versátil do ambiente R. É possível utilizar as instalações para
exibir uma ampla variedade de gráficos estatísticos e também para construir inteiramente novos tipos de gráfico.
As instalações gráficos podem ser usados em ambos os modos interactivo e em lote, mas na maioria dos casos, o uso
interativo é mais produtivo. uso interativo também é fácil porque na inicialização tempo R inicia uma gráfica driver do dispositivo que
abre uma especial janela de gráficos para a exibição de gráficos interativos. Embora isso é feito automaticamente, pode útil saber
que o comando usado é
X11 () sob o UNIX, janelas() no Windows e quartzo() sob macos. Um novo dispositivo pode sempre ser aberto por dev.new ().
Uma vez que o driver de dispositivo está sendo executado, comandos de plotagem R pode ser usado para produzir uma variedade de telas
gráficas e criar inteiramente novos tipos de display.
comandos de plotagem são divididos em três grupos básicos:
• Alto nível funções de plotagem criar um novo lote no dispositivo gráficos, possivelmente com machados, etiquetas, títulos e assim por diante.
• Nível baixo funções de plotagem adicionar mais informações para um lote existente, como pontos extras, linhas e etiquetas.
• Interativo funções de gráficos permitem que você interativamente adicionar informações para, ou extrair informações, uma trama
existente, usando um dispositivo apontador, como um mouse. Além disso, R mantém uma lista de parâmetros gráficas que pode ser
manipulado para personalizar suas parcelas.
Este manual apenas descreve o que são conhecidos como gráficos 'base'. Um subsistema de gráficos separada no pacote grade
coexiste com base - é mais poderoso, mas mais difícil de usar. Há um pacote recomendado treliça ( https://CRAN.R-project.org/package=lattice)
que se baseia em grade e fornece maneiras de produzir gráficos de vários painéis semelhantes aos do latada sistema em S.
12.1 comandos plotagem de alto nível

funções de plotagem de alto nível são projetados para gerar uma trama completa dos dados passados como argumentos para a função.
Se for caso disso, eixos, etiquetas e títulos são gerados automaticamente (a menos que você solicitar o contrário.) Comandos de
plotagem de alto nível sempre iniciar um novo enredo, apagando o enredo atual, se necessário.
12.1.1 O enredo() função

Uma das funções mais utilizadas plotagem em R é a enredo() função. Isto é um genérico
função: o tipo de trama produzido depende do tipo ou classe do primeiro argumento.
enredo( x, y)
enredo( xy) E se X e y são vectores, enredo( x, y) produz uma dispersão de y contra x. O mesmo
efeito pode ser produzido através do fornecimento de um argumento (segunda forma) quer como uma lista que contém dois
elementos X e y ou uma matriz de duas colunas.
enredo( x) E se X é uma série de tempo, isso produz um lote de séries temporais. E se X é um vector numérico, que produz um
gráfico dos valores no vector contra o seu índice de no vector. E se X
é um vector complexo, que produz um lote de imaginário contra partes reais dos elementos do vetor.
enredo( f)
enredo( f, y)
f é um factor de objecto, y é um vector numérico. A primeira forma gera um gráfico de barras do f;
a segunda forma de boxplots produz y para cada nível de f.
Capítulo 12: procedimentos gráficos 64
enredo( df)
trama (~ expr)
enredo( y ~ expr)
df é um quadro de dados, y é qualquer objeto, expr é uma lista de nomes de objectos separados por '+' (por exemplo, a + b + c). As
duas primeiras formas de produzir gráficos de distribuição das variáveis em uma trama de dados (primeira forma) ou de um número de
objectos chamados (segunda forma). A terceira parcelas do formulário y contra todo objeto nomeado em expr.
12.1.2 Exibindo dados multivariados

R proporciona duas funções muito úteis para a representação de dados multivariados. E se X é uma matriz ou estrutura de dados numéricos, o
comando
> pares (X)
produz uma matriz de dispersão de pares de variáveis definidas pelas colunas de X, isto é, a cada coluna de X é plotado contra
qualquer outra coluna de X e o resultante n (n - 1) tramas são dispostas numa matriz com trama escalas constante ao longo das
linhas e colunas da matriz.
Quando três ou quatro variáveis estão envolvidas a coplot pode ser mais esclarecedor. E se uma e b são vectores e numéricos c é
um vector ou factor objecto numérico (todos do mesmo comprimento), então o comando
> coplot (a ~ b | c)
produz uma série de diagramas de dispersão de uma contra b para valores dados de c. E se c é um fator, isto significa simplesmente que uma é
plotado contra b para cada nível de c. Quando c é numérico, ele é dividido em um número de intervalos condicionado e para cada intervalo uma é
plotado contra b para valores de c
dentro do intervalo. O número e posição dos intervalos pode ser controlada com given.values =
argumento para coplot () -a função co.intervals () é útil para seleccionar intervalos. Você também pode usar dois dado variáveis
com um comando como
> coplot (a ~ b | c d +)
que produz scatterplots de uma contra b para cada intervalo condicionado conjunta de c e d.
o coplot () e pares() funcionar tanto ter um argumento painel = que pode ser utilizado para personalizar o tipo de trama que aparece
em cada painel. O padrão é pontos() para produzir um gráfico de dispersão, mas através do fornecimento de alguma outra função de
baixo nível gráficos de dois vetores X e y como o valor de painel = você pode produzir qualquer tipo de gráfico que você deseja. Um
exemplo de função do painel é útil para coplots panel.smooth ().
12.1.3 Display graphics

Outras funções gráficas de alto nível produzir diferentes tipos de gráficos. Alguns exemplos são:
qqnorm (x) qqline

(x) qqplot (x, y)
parcelas de distribuição de comparação. A primeira forma traça o vector numérica X contra as pontuações normais
esperadas ordem (uma pontuação trama normal) e o segundo acrescenta uma linha recta para uma tal trama, traçando
uma linha através da distribuição e dados quartis. A terceira forma traça os quantis de X contra aqueles de y para
comparar as suas respectivas distribuições.
Hist (x)
Hist (x, Nclass = n)
Hist (x, quebras = b, ...)
Produz um histograma do vector numérico x. Um número razoável de classes é normalmente escolhido, mas uma
recomendação pode ser dado com a Nclass = argumento. Alternativamente, os pontos de interrupção pode ser
especificado exatamente com a breaks = argumento.
Se o probabilidade = TRUE argumento é dado, as barras representam frequências relativas dividido pela largura bin
em vez de contagens.
dotchart (x, ...)

Constrói um dotchart dos dados x. Em um dotchart o y- eixo dá uma rotulagem dos dados em X e a X- eixo dá o seu
valor. Por exemplo, permite a selecção visual fácil de todas as entradas de dados com os valores encontram-se em
intervalos especificados.
imagem (x, y, z, ...) de contorno

(x, y, z, ...) Persp (x, y, z, ...)
Parcelas de três variáveis. o imagem enredo desenha uma grade de retângulos usando cores diferentes para representar o
valor de z, a contorno chama a trama de linhas de contorno para representar o valor de z, e a persp trama desenha uma
superfície em 3D.
12.1.4 argumentos para funções de alto nível plotagem

Há uma série de argumentos que podem ser passados para funções gráficas de alto nível, como segue:
adicionar = TRUE Força a função de agir como uma função de baixo nível de gráficos, sobrepondo o enredo
no lote atual (algumas funções apenas).
eixos = FALSE
Suprime geração de eixos-útil para adicionar seus próprios eixos personalizados com o
eixo() função. O padrão, eixos = VERDADEIRO, meios incluem eixos.
log = "x" log = "y" log = "XY" faz com que o x, y ou ambos os eixos para ser logarítmica. Isto irá funcionar para muitos, mas não
tudo, tipos de enredo.
tipo = o tipo = argumento controla o tipo de trama produzidos, como se segue:
type = "p" pontos individuais da trama (o padrão)
type = "l" linhas de enredo
type = "b" tramas ligadas por linhas ( ambos)
type = "o" pontos da trama cobertas por linhas
type = "h" Traçar linhas verticais a partir de pontos em relação ao eixo de zero ( alta densidade)
Tipo = "s" type = "S" parcelas-função em degrau. Na primeira forma, o topo da vertical define a
ponto; na segunda, a parte inferior.
type = "n" Sem plotagem em tudo. No entanto eixos ainda são atraídos (por padrão) eo
sistema de coordenadas é configurado de acordo com os dados. Ideal para a criação de lotes com
funções subseqüentes gráficas de baixo nível.
XLAB = corda
ylab = corda
rótulos de eixo para o X e y eixos. Use esses argumentos para mudar as etiquetas padrão, geralmente os nomes dos
objetos usados na chamada para a função de plotagem de alto nível.
principais = corda
Figura título, colocado no topo da trama de uma grande fonte.
sub = corda
Sub-título, colocada logo abaixo do X- eixo em uma fonte menor.
12.2 comandos plotagem de baixo nível

Às vezes as funções de plotagem de alto nível não produzem exatamente o tipo de trama que você deseja. Neste caso, os comandos de
plotagem de baixo nível pode ser usado para adicionar a informação extra (como pontos, linhas ou texto) para a trama atual.
Algumas das funções de baixo nível de plotagem mais úteis são:
Os pontos (x, y) de
linhas (x, y)
Adiciona pontos ou linhas ligadas a trama actual. enredo() 's tipo = argumento também pode ser passada para
essas funções (e o padrão é " p" para pontos() e " eu" para
linhas ().)
texto (x, y, rótulos, ...)

Adicionar texto a uma trama de pontos dados por x, y. Normalmente etiquetas é um vector de número inteiro ou de
caracteres em cujo caso etiquetas [i] é plotado no ponto ( x [i], y [i]). O padrão é 1: comprimento (x).
Nota: Esta função é muitas vezes utilizado na sequência
> trama (x, y, type = "n"); texto (x, y, nomes)
O parâmetro gráficos type = "n" suprime os pontos, mas define-se os eixos, eo texto() função fornece
caracteres especiais, conforme especificado pelo vector caráter
nomes para os pontos.
abline (a, b) abline

(h = y)
abline (v = x)
abline ( lm.obj)
Adiciona uma linha de inclinação b e interceptar uma para a trama atual. h = y pode ser usado para especificar y- coordenadas
para as alturas de linhas horizontais de ir através de uma trama, e
v = X Da mesma forma para a X- Coordenadas por linhas verticais. Além disso lm.obj pode ser uma lista com um
coeficientes componente de comprimento de 2 (tal como o resultado de funções de ajuste do modelo,) que são tomadas como
uma intercepção e inclinação, nessa ordem.
polígono (x, y, ...)

Desenha um polígono definido pelos vértices ordenados em ( x, y) e (opcionalmente) em enrolá-lo com linhas de escotilha, ou
enchê-lo se o dispositivo gráfico permite o enchimento de figuras.
legenda (x, y, legenda, ...)

Adiciona uma lenda para a trama atual na posição especificada. Plotagem personagens, estilos de linhas, cores, etc.,
são identificados com as etiquetas no vetor de caracteres lenda. Pelo menos um outro argumento v ( um vector do
mesmo comprimento que lenda) com os valores correspondentes da unidade de trama também deve ser dado, como
segue:
legenda (, preencha = v)
Cores para caixas cheias
legenda (, col = v)
Cores em que pontos ou linhas serão desenhadas
legenda (, = LTY v)
estilos de linha
legenda (, LWD = v)
larguras de linha
legenda (, PCH = v)
caracteres plotagem (vector personagem)
título (principal, sub)

Adiciona um título a Principal para o topo da trama actual numa grande fonte e (opcionalmente) uma sub-título sub na parte
inferior de uma fonte menor.
eixo (lado, ...)

Adiciona um eixo para a trama actual no lado dada pelo primeiro argumento (1-4, contando no sentido horário a
partir do fundo.) Outros argumentos controlar o posicionamento do eixo dentro ou ao lado do terreno, e carrapatos
posições e etiquetas. Útil para adicionar eixos personalizados depois de chamar enredo() com o eixos = FALSE argumento.
funções de plotagem de baixo nível geralmente requerem algumas informações de posicionamento (por exemplo, X e y coordena) para determinar
onde colocar os novos elementos do enredo. As coordenadas são dadas em termos de
coordenadas do usuário os quais são definidos pelo anterior comando de alto nível ilustrações e são escolhidos com base nos dados
fornecidos.
Onde X e y argumentos são necessários, também é suficiente para abastecer um único argumento de ser uma lista com elementos nomeados X e y.
Da mesma forma uma matriz com duas colunas é também uma entrada válida. Desta forma funções tais como localizador () ( ver abaixo) pode ser
utilizado para especificar posições sobre uma trama de forma interactiva.
12.2.1 anotação Matemática

Em alguns casos, é útil para adicionar símbolos matemáticos e fórmulas para a trama. Isto pode ser conseguido em R
especificando um expressão em vez de uma cadeia de caracteres em qualquer uma das texto, mtext, eixo, ou título. Por exemplo, o
seguinte código desenha a fórmula para a função de probabilidade binomial:
> texto (x, y, a expressão (pasta (bgroup ( "(", no topo (n, x) ")"), p ^ x, q ^ {nx})))
Mais informações, incluindo uma lista completa das características lata disponível obtido a partir de dentro R usando os
comandos:
> ajuda (plotmath)

> exemplo (plotmath)
> demo (plotmath)
12.2.2 fontes vetoriais Hershey

É possível especificar fontes vetoriais Hershey para processamento de texto quando se usa o texto e contorno
funções. Há três razões para usar as fontes Hershey:
• fontes Hershey pode produzir a melhor saída, especialmente em uma tela de computador, para o texto rodado e / ou pequeno.
• fontes Hershey fornecer certos símbolos que podem não estar disponíveis nas fontes padrão. Em particular, há signos do
zodíaco, símbolos cartográficos e símbolos astronômicos.
• fontes Hershey fornecer caracteres cirílicos e japoneses (Kana e Kanji).
Mais informações, incluindo tabelas de caracteres Hershey pode ser obtido a partir de dentro R usando os comandos:
> ajuda (Hershey)

> demo (Hershey)
> ajuda (Japonês)
> demo (japonês)
12,3 Interagindo com gráficos

R também fornece funções que permitem aos usuários extrair ou adicionar informações a uma trama usando um mouse. A mais
simples delas é a localizador() função:
localizador (n, tipo)

Aguarda que o usuário selecione locais no lote atual usando o botão esquerdo do mouse. Isso continua até que n
( default 512) pontos foram selecionados, ou outro botão do mouse é pressionado. o tipo argumento permite a
plotagem nos pontos selecionados e tem o mesmo efeito que para comandos gráficos de alto nível; O padrão é
sem plotagem.
localizador() Retorna a localização dos pontos selecionados como uma lista com dois componentes
X e y.
localizador() é geralmente chamado sem argumentos. É particularmente útil para seleccionar interactivamente posições de
elementos gráficos tais como lendas ou rótulos quando é difícil calcular antecipadamente o gráfico onde deve ser colocado. Por
exemplo, para colocar algum texto informativo perto de um ponto afastado, o comando
> texto (localizador (1), "Outlier", adj = 0)
pode ser útil. ( localizador() será ignorado se o dispositivo atual, como pós-escrito não suporta apontando interativo.)
identificar (x, y, etiquetas)

Permitir que o usuário para selecionar qualquer um dos pontos definidos pela X e y ( utilizando o botão esquerdo do
mouse) traçando o componente correspondente de etiquetas próximos (ou o número de índice do ponto se etiquetas está
ausente). Retorna os índices dos pontos selecionados quando outro botão é pressionado. Às vezes queremos identificar especial pontos
em um terreno, ao invés de suas posições. Por exemplo, nós podemos desejar que o usuário selecione alguma observação de
interesse a partir de um display gráfico e, em seguida, manipular que a observação de alguma forma. Dado um número de ( x, y) Coordenadas
em dois vectores numéricos X e y, poderíamos usar o identificar() função como se segue:
> trama (x, y)

> identificar (x, y)
o identificar() funções não executa nenhuma plotagem em si, mas simplesmente permite que o usuário mova o ponteiro do mouse e
clique no botão esquerdo do mouse próximo a um ponto. Se houver um ponto próximo do ponteiro do rato que vai ser marcado com o seu
número de índice (isto é, a sua posição no x / y vetores) plotados nas proximidades. Alternativamente, você poderia usar alguma corda
informativo (como um nome caso) como um destaque usando a etiquetas argumento para identificar(), ou desativar a marcação em conjunto
com o
Lote = FALSE argumento. Quando o processo é finalizado (ver acima), identificar() retorna os índices dos pontos seleccionados;
você pode usar esses índices para extrair os pontos selecionados a partir dos vetores originais X e y.
12.4 Usando parâmetros gráficos

Quando a criação de gráficos, especialmente para fins de apresentação ou publicação, defaults de R nem sempre produzir
exatamente o que é necessário. Você pode, no entanto, personalizar quase todos os aspectos da exibição usando parâmetros
gráficos. R mantém uma lista de um grande número de parâmetros gráficos que controlam coisas como estilo de linha, cores,
figura arranjo e justificação do texto, entre muitos outros. Cada parâmetro gráfica tem um nome (como ' col ', Que controla a
cores) e um valor (um número de cor, por exemplo.)
Uma lista separada de parâmetros gráficos é mantido para cada dispositivo ativo, e cada dispositivo tem um conjunto padrão de
parâmetros quando inicializado. parâmetros gráficos pode ser definida de duas maneiras: ou permanentemente, afetando todas as funções
gráficas que acessam o dispositivo atual; ou temporariamente, afetando apenas um único gráficos função de chamada.
12.4.1 mudanças permanentes: Os par() função

o par() função é usada para acessar e modificar a lista de parâmetros gráficos para o dispositivo gráfico atual.
par() Sem argumentos, retorna uma lista de todos os parâmetros gráficos e seus valores para o dispositivo atual.
par (c ( "col", "LTY"))

Com um argumento de caráter vetor, retorna apenas os parâmetros gráficos chamados (mais uma vez, como uma lista.)
par (col = 4, LTY = 2)

Com argumentos nomeados (ou um único argumento lista), define os valores dos parâmetros gráficos
chamados, e devolve os valores originais dos parâmetros como uma lista. Definir gráficos parâmetros com o par() função
altera o valor dos parâmetros
permanentemente, no sentido de que todas as futuras chamadas para funções de gráficos (no dispositivo atual) será afetado pelo novo
valor. Você pode pensar em definir parâmetros gráficos desta forma como a definição de valores “padrão” para os parâmetros, que
serão utilizados por todas as funções de gráficos, a menos que um valor alternativo é dado.
Nota que as chamadas para par() sempre afetar os valores globais de parâmetros gráficos, mesmo quando
par() é chamado de dentro de uma função. Isso é muitas vezes o comportamento, geralmente indesejável queremos definir alguns
parâmetros gráficos, fazer alguma plotagem, e em seguida, restaurar os valores originais de modo a não afetar a sessão R do usuário. Você
pode restaurar os valores iniciais, salvando o resultado de par()
ao fazer alterações, e a restauração dos valores iniciais quando traçando é completa.
> oldpar <- par (col = 4, LTY = 2)
. . . plotagem comandos. . .
> par (oldpar)
Para salvar e restaurar todos configurável 1 parâmetros gráficas usar
> oldpar <- par (no.readonly = TRUE)

. . . plotagem comandos. . .
> par (oldpar)
12.4.2 mudanças temporárias: Argumentos para funções gráficas

parâmetros gráficos também podem ser passadas para (quase) qualquer função gráficos como argumentos nomeados. Isto tem o
mesmo efeito que passar os argumentos para o par() função, exceto que as alterações duram apenas para a duração da chamada de
função. Por exemplo:
> trama (x, y, PCH = "+")

produz um gráfico de dispersão usando um sinal de mais como o personagem plotagem, sem alterar o padrão traçando caracteres para
parcelas futuras.
Infelizmente, isso não é totalmente implementado de forma consistente e, por vezes, é necessário definir e redefinir
parâmetros gráficos usando par().
Lista de 12,5 parâmetros Gráficas

O detalhe seguintes seções muitos dos parâmetros gráficos comumente usados. A documentação R ajuda para o par() função
fornece um resumo mais concisa; isto é fornecido como uma alternativa um pouco mais detalhada.
parâmetros gráficos serão apresentados na forma seguinte:
name = valor
A descrição do efeito do parâmetro. nome é o nome do parâmetro, isto é, o nome do argumento para usar em
chamadas para par() ou uma função de gráficos. valor é um valor típico que você pode usar ao definir o parâmetro.
Observe que eixos é não um parâmetro de gráficos, mas um argumento para alguns enredo métodos: veja
xaxt e yaxt.
1 Alguns parâmetros gráficos, tais como o tamanho do dispositivo atual são apenas para informação.
12.5.1 elementos gráficos

parcelas de R são compostas de pontos, linhas, texto e polígonos (regiões preenchidas.) existem parâmetros gráficos que controlam a forma como
estes elementos gráficos são desenhados, como segue:
pch = "+" Caractere a ser usado para traçar pontos. O padrão varia com drivers gráficos,
mas é normalmente ' ◦ '. Pontos traçados tendem a aparecer um pouco acima ou abaixo da posição apropriada a
menos que você use "" como o personagem plotagem, que produz pontos centrados.
PCH = 4 Quando PCH é dada como um número inteiro entre 0 e 25, inclusive, um símbolo trama especializado é
produzido. Para ver o que os símbolos são, use o comando
> legenda (localizador (1), as.character (00:25), PCH = 00:25)
Aqueles de 21 a 25 podem aparecer para duplicar símbolos anteriores, mas pode ser colorido de diferentes maneiras:
consulte a ajuda pontos e os seus exemplos. Além do que, além do mais, PCH pode ser um personagem ou um número no
intervalo 32: 255 representando um caractere na fonte atual.
LTY = 2 tipos de linhas. estilos de linha alternativos não são suportados em todos os dispositivos gráficos (e variar sobre aqueles que
fazer), mas linha de tipo 1 é sempre uma linha a cheio, linha de tipo 0 é sempre invisível, e tipos de linhas 2 e seguintes são
linhas tracejadas ou pontilhadas, ou alguma combinação de ambos.
LWD = 2 larguras de linha. largura desejada de linhas, em múltiplos de largura de linha “padrão”. Afecta linhas de eixo, bem como
com linhas desenhadas (linhas), etc. Nem todos os dispositivos suportam esta, e alguns têm restrições sobre as larguras
que podem ser usados.
col = 2 Cores a serem utilizadas para pontos, linhas, texto, regiões e imagens cheias. Um número a partir da paleta
atual (ver? paleta) ou uma cor nomeada.
col.axis col.lab col.main col.sub A cor a ser usada para anotação eixo, X e y etiquetas, principal e sub-títulos, re-
pectivamente.
fonte = 2 Um número inteiro que especifica qual fonte a ser usada para o texto. Se possível, drivers de dispositivo organizar para que 1
corresponde a texto simples, 2 para negrito, 3 para itálico, 4 a negrito itálico e 5 a uma fonte de símbolo (que incluem letras
gregas).
font.axis font.lab font.main font.sub A fonte a ser usada para anotação eixo, X e y etiquetas, principal e sub-títulos, respec-
vamente.
aj = -0,1 Justificação de texto em relação à posição de plotagem. 0 meios esquerda justificar, 1 significa
direito justificar e 0,5 meios para centrar horizontalmente sobre a posição trama. O valor real é a proporção de
texto que aparece à esquerda da posição de plotagem, então um valor de - 0,1 deixa um intervalo de 10% da
largura do texto entre o texto e a posição de trama.
CEX = 1,5 expansão personagem. O valor é o tamanho desejado de caracteres de texto (incluindo
traçando caracteres) em relação ao tamanho do texto padrão.
cex.axis cex.lab cex.main cex.sub A expansão caractere a ser usado para anotação eixo, X e y etiquetas, principal e
subtítulos, respectivamente.
12.5.2 Axes e marcas de escala

Muitos dos lotes de alto nível de R têm machados, e você pode construir eixos-se com o baixo nível
eixo() função de gráficos. Eixos tem três componentes principais: o linha de eixo ( estilo de linha controlado pelo LTY gráficos de
parâmetros), o Marcas de escala ( que marcar divisões de unidade ao longo da linha de eixo) e os Rótulos de escala ( que marcam as
unidades.) Esses componentes podem ser personalizado com parâmetros gráficos seguintes.
laboratório = C (5, 7, 12)
Os primeiros dois números são o número desejado de intervalos de carrapato na X e y eixos respectivamente. O terceiro
número é o comprimento desejado de rótulos de eixo, em caracteres (incluindo o ponto decimal.) Escolhendo um demasiado
pequeno valor para este parâmetro pode resultar em todos os rótulos de escala a ser arredondado para o mesmo número!
las = 1 Orientação de rótulos de eixo. 0 significa sempre paralela ao eixo, 1 significa sempre horizontal, e 2 significa
sempre perpendicular ao eixo.
mgp = c (3, 1, 0)
Posições de componentes de eixo. O primeiro componente é a distância entre a etiqueta eixo para a posição do
eixo, em linhas de texto. O segundo componente é a distância para os rótulos de escala, e o componente final é a
distância a partir da posição do eixo para a linha de eixo (normalmente zero). Os números positivos medida fora da
região de trama, os números negativos dentro.
tck = 0,01 Comprimento de marcas de verificação, como uma fracção do tamanho da região de trama. Quando tck
é pequena (menos do que 0,5) as marcas de escala na X e y eixos são forçados a ter o mesmo tamanho. Um valor de 1
indica as linhas de grade. Os valores negativos dar marcas de escala fora da região da plotagem. Usar tck = 0,01 e mgp = C
(1, -1.5,0) para marcas de escala internos.
xaxs = "R" yaxs = "i" estilos de eixo para o X e y eixos, respectivamente. Com estilos " Eu" ( interna) e " r"
(O padrão) marcas de escala sempre caem dentro do intervalo de dados, no entanto estilo " r"
deixa uma pequena quantidade de espaço nas bordas. (S tem outros estilos não implementadas em
R.)
12.5.3 margens Forma

Um único lote em R é conhecido como um figura e compreende um região trama rodeado por margens (possivelmente contendo
etiquetas de eixos, títulos, etc) e (normalmente) delimitadas pelos próprios eixos.
A figura é típico
------------------ ---------- -------- Mar [3]

-------------- ---- ------------------
------------------ ------------------
3.0
região Plot
1.5
0.0
y
mai [2]
−1.5
−3.0
-3.0 -1.5 0.0 1.5 3,0
mai [1] X
Margem
Gráficos parâmetros que controlam o layout figura incluem:
mai = C (1, 0,5, 0,5, 0)

Larguras do fundo, à esquerda, as margens superior e direita, respectivamente, medidas em polegadas.
Mar = c (4, 2, 2, 1)
Igual a mai, excepto a unidade de medida é linhas de texto.
estragar e mai são equivalentes, no sentido de que a fixação de um muda o valor do outro. Os valores padrão escolhido para
este parâmetro são muitas vezes demasiado grande; a margem direita é raramente necessário, e nem é a margem superior se
nenhum título está sendo usado. As margens inferior e esquerda deve ser grande o suficiente para acomodar o eixo e carrapatos
etiquetas. Além disso, o padrão é escolhido independentemente do tamanho da superfície do dispositivo: por exemplo, utilizando o pós-escrito
()
driver com o altura = 4 argumento vai resultar em uma trama que é cerca de 50% a menos margem estragar
ou mai são definidas explicitamente. Quando vários números estão em uso (veja abaixo), as margens são reduzidas, no entanto, isso pode não ser
suficiente quando muitas figuras compartilham a mesma página.
12.5.4 ambiente Multiple figura

R permite que você crie um n por m matriz de dados num único principal. Cada figura tem as suas próprias margens, e a gama de
valores é opcionalmente rodeada de um margem exterior, como mostrado na figura a seguir.
--------------- oma [3]

--------------- ----- ----------
--------------- ---------------
omi [4]
mfg = c (3,2,3,2)
omi [1]
mfrow = c (3,2)
Os parâmetros gráficos relativos a vários números são os seguintes:
mfcol = c (3, 2)
mfrow = c (2, 4)
Definir o tamanho de uma matriz figura múltipla. O primeiro valor é o número de linhas; o segundo é o número
de colunas. A única diferença entre estes dois parâmetros é que definição mfcol provoca figuras a serem
preenchidos por coluna; mfrow enche de linhas. O layout na Figura poderia ter sido criado através da criação mfrow
= c (3,2); a figura mostra a página após quatro parcelas foram desenhados.
Definir qualquer um destes pode reduzir o tamanho da base de símbolos e texto (controlada pela
nominal ( "CEX") e o pointsize do dispositivo). Numa disposição com exactamente duas linhas e colunas do tamanho
de base é reduzido por um factor de 0,83: se existem três ou mais de qualquer das filas ou colunas, o factor de
redução é de 0,66.
mfg = c (2, 2, 3, 2)
Posição da figura atual em um ambiente figura múltipla. Os primeiros dois números são a linha e a coluna da
figura corrente; os dois últimos são o número de linhas e colunas na matriz figura múltipla. Defina este
parâmetro para saltar entre os números na matriz. Você ainda pode usar valores diferentes para os dois últimos
números do que a
verdade valores para números desigual porte na mesma página.
Fig = c (4, 9, 1, 4) / 10
Posição do número atual na página. Os valores são as posições da esquerda, direita, parte inferior e bordas superior,
respectivamente, como uma percentagem da página medido a partir do canto inferior esquerdo. O valor exemplo seria para
uma figura no canto inferior direito da página. Defina este parâmetro para o posicionamento arbitrário de números dentro de
uma página. Se você deseja adicionar uma figura para uma página atual, o uso nova = TRUE bem como (ao contrário S).
oma = c (2, 0, 3, 0) omi = c

(0, 0, 0,8, 0)
Tamanho das margens exteriores. Gostar estragar e mai, as primeiras medidas em linhas de texto e o segundo em polegadas,
começando com a margem inferior e no sentido horário de trabalho.
margens exteriores são particularmente úteis para títulos de página-sábio, etc. O texto pode ser adicionado às margens exteriores, com a mtexto
() função com argumento exterior = VERDADEIRO. Não há margens externas por padrão, no entanto, assim que você deve criá-los explicitamente
usando oma ou omi.
arranjos mais complicados de várias figuras podem ser produzidos pela tela dividida()
e layout () funções, assim como pela grade e treliça ( https://CRAN.R-project.org/ pacote = reticulado) pacotes.
12.6 Os drivers de dispositivo
R pode gerar gráficos (de diferentes níveis de qualidade) em quase qualquer tipo de monitor ou dispositivo de impressão. Antes que isto
possa começar, no entanto, R precisa ser informado que tipo de dispositivo que está lidando. Isso é feito por iniciar um driver do dispositivo. A
finalidade de um controlador de dispositivo é para converter as instruções gráficas de R ( “desenhar uma linha”, por exemplo) para uma
forma que o dispositivo particular pode compreender.
Os drivers de dispositivo são iniciados por chamar uma função de driver de dispositivo. Há uma tal função para cada driver de
dispositivo: Tipo ajuda (dispositivos) Para obter uma lista de todos eles. Por exemplo, emitir o comando
> pós-escrito ()
faz com que todos os futuros saída de gráficos para serem enviados para a impressora em formato PostScript. Alguns drivers de dispositivo commonlyused são:
X11 () Para uso com o sistema de janelas X11 em Unix-alikes
janelas()
Para uso no Windows
quartzo() Para uso no MacOS
pós-escrito ()
Para imprimir em impressoras PostScript, ou a criação de arquivos PostScript gráficos.
pdf () Produz um arquivo PDF, que também podem ser incluídos em arquivos PDF.
PNG () Produz um arquivo de bitmap PNG. (Nem sempre está disponível: ver a sua página de ajuda.)
JPEG () Produz um arquivo de bitmap JPEG, melhor usado para imagem parcelas. (Nem sempre está disponível: ver a sua página de ajuda.)
Quando tiver terminado com um dispositivo, certifique-se de terminar o driver de dispositivo, emitindo o comando
> dev.off ()
Isto garante que o dispositivo termina limpa; por exemplo, no caso de dispositivos impressos isso garante que cada página
é concluído e foi enviado para a impressora. (Isso acontecerá automaticamente no final normal de uma sessão.)
12.6.1 diagramas PostScript para documentos typeset

Ao passar o Arquivo argumento para o pós-escrito () função de driver de dispositivo, você pode armazenar os gráficos em formato
PostScript em um arquivo de sua escolha. A trama será na orientação paisagem, a menos que o horizontal = FALSE argumento é
dado, e você pode controlar o tamanho do gráfico com o largura e altura argumentos (a trama será dimensionada como apropriado
para se ajustar estas dimensões). Por exemplo, o comando
> postscript ( "file.ps", horizontal = FALSO, altura = 5, 10) = PointSize
irá produzir um arquivo contendo código PostScript para uma figura cinco polegadas de altura, talvez para inclusão em um
documento. É importante notar que, se o arquivo nomeado no comando já existe,
ele será substituído. Este é o caso, mesmo que o arquivo só foi criado anteriormente na mesma sessão R.
Muitos usos de saída PostScript será incorporar a figura em outro documento. Isso funciona melhor quando encapsulado PostScript
é produzida: R sempre produz uma saída conformant, mas apenas marca a saída como tal, quando o OneFile = FALSE argumento
é fornecido. Esta notação incomum deriva de S-compatibilidade: ele realmente significa que a saída será uma única página (que
é parte da especificação EPSF). Assim, para produzir um lote de uso de inclusão algo como
> PostScript ( "plot1.eps", horizontais = FALSE, OneFile = FALSE,

altura = 8, largura = 6, pointsize = 10)
12.6.2 Múltiplos dispositivos gráficos

Em uso avançado de R muitas vezes é útil ter vários dispositivos gráficos em uso ao mesmo tempo. Claro dispositivo apenas uma
gráfica pode aceitar gráficos comandos a qualquer momento, e isso é conhecido como o dispositivo atual. Quando vários dispositivos
estão abertos, eles formam uma sequência numerada com nomes dando o tipo de dispositivo, em qualquer posição.
Os principais comandos usados para operar com vários dispositivos, e seus significados são os seguintes:
X11 () [UNIX]
Windows () win.printer
() win.metafile ()
[Janelas]
quartzo () [ Mac OS]
pós-escrito () pdf ()
PNG ()
JPEG ()
TIFF ()
bitmap ()
. . . Cada nova chamada para uma função de driver de dispositivo abre um novo dispositivo gráfico, alargando assim a uma
lista de dispositivos. Este dispositivo torna-se o dispositivo atual, ao qual será enviada saída gráfica.
dev.list ()
Retorna o número eo nome de todos os dispositivos ativos. O dispositivo na posição 1 na lista é sempre o dispositivo
nulo que não aceita gráficos comandos em tudo.
dev.next ()
dev.prev ()
Retorna o número eo nome do dispositivo gráfico ao lado, ou anterior para o dispositivo atual, respectivamente.
dev.set (que é = k)
Pode ser usado para mudar o atual dispositivo gráfico ao que na posição k da lista de dispositivos. Retorna o
número e rótulo do dispositivo.
dev.off ( k)
Rescindir o dispositivo gráfico no ponto k da lista de dispositivos. Para alguns dispositivos, tal como
pós-escrito dispositivos, este será ou imprimir o arquivo imediatamente ou corretamente completar o arquivo para impressão
posterior, dependendo de como o dispositivo foi iniciado.
dev.copy (dispositivo, ..., que é = k)

dev.print (dispositivo, ..., que é = k)
Faça uma cópia do dispositivo k. Aqui dispositivo é uma função do dispositivo, tal como postscript,
com argumentos extras, se necessário, especificado por '...'. dev.print é semelhante, mas o dispositivo copiado é imediatamente
fechada, de modo que as acções de extremidade, tais como cópias em papel de impressão, são realizadas imediatamente.
graphics.off ()
Terminar todos os dispositivos gráficos na lista, exceto o dispositivo nulo.
12,7 gráficos dinâmicos

R não tem embutido capacidades para gráficos dinâmicos ou interativos, por exemplo rotação nuvens de pontos ou para “escovar”
(interativa destacando) pontos. No entanto, extensas instalações de gráficos dinâmicos estão disponíveis no sistema GGobi por
Swayne, Cook e Buja disponível a partir de
http://www.ggobi.org/
e estes podem ser acedidos a partir de R através do pacote rggobi ( https://CRAN.R-project.org/ pacote = rggobi), descrito em http://www.ggobi.org/
Além disso, o pacote RGL ( https://CRAN.R-project.org/package=rgl) fornece maneiras de interagir com parcelas em 3D, por
exemplo de superfícies.
77
13 Pacotes
Todas as funções R e conjuntos de dados são armazenados em pacotes. Apenas quando um pacote é carregado estão seu conteúdo
disponível. Isto é feito tanto para a eficiência (a lista completa levaria mais memória e levaria mais tempo para procurar do que um
subconjunto), e para ajudar os desenvolvedores de pacotes, que são protegidos de confrontos com nome outro código. O processo de
pacotes em desenvolvimento é descrito em “Criando pacotes R” em Escrevendo extensões de R. Aqui, vamos descrevê-los do ponto de
vista de um usuário.
Para ver quais pacotes são instalados em seu site, emitir o comando
> biblioteca()
sem argumentos. Para carregar uma embalagem particular (por exemplo, a boot ( https: //CRAN.R-project. org / pacote =
inicialização) pacote contendo funções de Davison & Hinkley (1997)), utiliza-se
> biblioteca (boot)
Usuários conectados à Internet pode usar o install.packages () e update.packages ()

funções (disponíveis através da pacotes Menu nas GUIs do Windows e MacOS, veja o capítulo “Instalando pacotes” em R
Installation and Administration) instalar e atualizar pacotes.
Para ver quais pacotes estão actualmente carregados, o uso
> procurar()
para exibir a lista de pesquisa. Alguns pacotes podem ser carregados mas não está disponível na lista de pesquisa (ver Seção 13.3
[namespaces], página 78): estes serão incluídos na lista dada pela
> loadedNamespaces ()
Para ver uma lista de todos os tópicos de ajuda disponíveis em um pacote instalado, use
> help.start ()
para iniciar o sistema de ajuda HTML, e em seguida, navegue para a lista de pacotes no Referência
seção.
13.1 pacotes padrão

O padrão (ou base) pacotes são considerados parte do código-fonte R. Eles contêm as funções básicas que permitem que R a
trabalhar, e os conjuntos de dados e funções estatísticas e gráficos padrão que são descritos neste manual. Eles devem estar
automaticamente disponíveis em qualquer instalação R. Consulte a seção “pacotes R” em R FAQ, para uma lista completa.
13.2 pacotes de Contribuição e CRAN

Existem milhares de pacotes contribuíram para R, escritos por diversos autores. Alguns desses pacotes implementar métodos
estatísticos especializados, outros dão acesso a dados ou hardware, e outros são projetados para complementar livros
didáticos. Alguns (a recomendado pacotes) são distribuídos com cada distribuição binária do R. A maioria está disponível para
download a partir CRAN ( https://CRAN.R-project.org/ e seus espelhos) e outros depósitos tais como Bioconductor ( https://www.bioconductor.org/).
e Omegahat ( http://www.omegahat.net/). o
R FAQ contém uma lista de CRAN pacotes atuais no momento da liberação, mas a coleção de pacotes disponíveis muda com
muita freqüência.
Capítulo 13: Pacotes 78
13.3 Namespaces
pacotes têm namespaces, que fazer três coisas: eles permitem que o escritor pacote para esconder funções e dados que são
destinados apenas para uso interno, evitam funções de quebrar quando um usuário (ou outro escritor do pacote) escolhe um nome
que se choca com um no pacote, e eles fornecer um modo para se referir a um objecto dentro de um determinado pacote.
Por exemplo, t () é a função de transposição em R, mas os usuários podem definir a sua própria função chamada t. Namespaces
prevenir definição do usuário de tomar precedência, e quebrando todas as funções que tenta transpor uma matriz.
Há dois operadores que trabalham com namespaces. O operador dois pontos duplo :: seleciona definições de um
namespace particular. No exemplo acima, a função de transposição estará sempre disponível como de base :: t, porque ela é
definida na base pacote. Somente funções que são exportados a partir do pacote pode ser recuperada desta maneira.
O operador de triplo-cólon ::: pode ser visto em alguns lugares no código R: ele atua como o operador dois-pontos, mas
também permite o acesso a objetos escondidos. Os usuários são mais propensos a usar o getAnywhere () função, que procura
vários pacotes.
Os pacotes são frequentemente inter-dependentes, e uma carga pode causar outros para ser carregada automaticamente. Os operadores
do cólon descritos acima também fará com que o carregamento automático do pacote associado. Quando pacotes com namespaces são
carregados automaticamente eles não são adicionados à lista de pesquisa.
79
14 instalações de SO
R tem instalações muito extensas para acessar o sistema operacional em que ele está sendo executado: isto permite que ele seja usado como uma
linguagem de script e que a capacidade é muito usado por si só R, por exemplo, para instalar pacotes.
Porque próprios scripts de R precisa trabalhar em todas as plataformas, um esforço considerável tem ido para fazer as instalações de
script como plataforma independente quanto possível.
14.1 Arquivos e diretórios

Há muitas funções para manipular arquivos e diretórios. Aqui estão os ponteiros para alguns dos mais comumente usados.
Para criar um arquivo (Vazio) ou diretório, o uso File.Create ou dir.create. ( Estes são os análogos dos utilitários POSIX tocar
e Mkdir.) Para arquivos e diretórios temporários no diretório de sessão de R ver tempfile.
Os ficheiros podem ser removidos por qualquer file.remove ou desvincular: este último pode remover árvores de diretório.
Para listagens de diretórios uso list.files ( também disponível como dir) ou list.dirs. Estes podem selecionar arquivos usando uma expressão
regular: para selecionar por wildcards uso Sys.glob.
Muitos tipos de informações sobre um caminho de arquivo (incluindo, por exemplo, se é um arquivo ou diretório) pode ser encontrado informações do
arquivo.
Existem várias maneiras de descobrir se um arquivo 'existe' (um arquivo pode existir no sistema de arquivos e não ser
visível para o usuário atual). Existem funções File.Exists, file.access e file_test
com várias versões deste teste: file_test é uma versão do POSIX teste comando para aqueles familiarizados com shell script.
Função File.Copy é análogo a R do comando POSIX cp.
arquivos Escolhendo pode ser feito de forma interativa, file.choose: a porta do Windows tem as funções mais versáteis escolher
os arquivos e choose.dir e existem funções semelhantes no tcltk
pacote: tk_choose.files e tk_choose.dir.
Funções file.show e file.edit irá exibir e editar um ou mais arquivos de uma forma adequada à porta R, utilizando as
instalações de um console (como Rgui no Windows ou R.app no MacOS), se um está em uso.
Há algum suporte para ligações no sistema de arquivos: ver funções file.link e Sys.readlink.
14.2 Caminhos de arquivos
Com poucas exceções, R conta com as funções de sistema operacional subjacente para manipular filepaths. Alguns aspectos desta estão
autorizados a depender do sistema operacional, e fazer, mesmo para baixo para a versão do OS. Existem padrões POSIX de como sistemas
operacionais deve interpretar filepaths e muitos usuários R assumir conformidade POSIX, mas o Windows não pretensão de ser complacente e
outros sistemas operacionais pode ser menos do que completamente compatível.
A seguir estão algumas questões que foram encontrados com filepaths.
• sistemas de ficheiros POSIX são caso-sensível, por isso foo.png e Foo.PNG são diferentes arquivos. No entanto, os padrões em Windows e
MacOS são para ser maiúsculas e minúsculas, e sistemas de ficheiros FAT (vulgarmente utilizados no armazenamento removível) não são
normalmente caso-sensível (e todos os filepaths pode ser mapeado para minúsculas).
• Quase todos os serviços do sistema operacional do Windows' apoiar o uso de barra ou barra invertida como separador de caminho de
arquivo, e R converte as exceções conhecidas à forma exigida pelo Windows.
Capítulo 14: instalações OS 80
• O comportamento de filepaths com uma barra final é dependente do sistema operacional. Esses caminhos não são válidos no Windows e
não deve ser esperado para trabalhar. POSIX-2008 exige tais caminhos para corresponder apenas diretórios, mas versões anteriores
permitiu-lhes também corresponder arquivos. Assim, eles devem ser evitados.
• Várias barras em filepaths como / abc // def são válidos em sistemas de arquivos POSIX e tratado como se houvesse apenas um
golpe. Eles são usualmente aceito por funções do sistema operacional Windows. No entanto, barras duplas líderes pode ter um
significado diferente.
• Janelas' UNC filepaths (tal Como \ Dir1 \ dir2 \ file server \\ e

\\? \ UNC \ server \ dir1 \ dir2 \ arquivo) não são suportados, mas eles podem trabalhar em algumas funções R. sistemas de ficheiros POSIX
são permitidas para o tratamento de uma barra dupla conduzindo especialmente.
• Windows permite filepaths contendo unidades e em relação ao diretório atual em uma unidade,
por exemplo d: foo / barra refere-se a d: / a / b / c / foo / barra se o diretório atual na unidade d: é / abc.
Pretende-se que estes trabalhos, mas o uso de caminhos absolutos é mais seguro. Funções basename e dirname selecionar partes
de um caminho de arquivo: a maneira recomendada para montar um caminho de arquivo a partir de componentes é caminho de arquivo. Função
pathexpand faz 'expansão til', substituindo valores para diretórios home (do usuário atual, e talvez aqueles de outros usuários).
Em sistemas de arquivos com links, um único arquivo pode ser referido por muitos filepaths. Função
normalizePath vai encontrar um caminho de arquivo canônico.
Windows tem os conceitos de curto ( '8.3') e nomes de arquivos longos: normalizePath irá retornar um caminho absoluto
usando nomes de arquivo longos e shortPathName irá retornar uma versão usando nomes curtos. Este último não contém espaços
e usa barra invertida como separador, por isso às vezes é útil para exportar nomes de R.
Arquivo permissões são um tópico relacionado. R tem suporte para os conceitos POSIX de
leitura / gravação / permissão de execução para proprietário / grupo / all mas isso pode ser apenas parcialmente suportado no sistema de
arquivos, assim, por exemplo apenas no Windows arquivos somente leitura (para a conta executando a sessão R) são reconhecidas. Access
Control Lists (ACLs) são empregados em vários sistemas de arquivos, mas não têm uma norma acordada e R não tem instalações para
controlá-los. Usar Sys.chmod para alterar as permissões.
14.3 Comandos do sistema

Funções sistema e system2 são usados para invocar um comando do sistema e, opcionalmente, recolher a sua saída. system2 é um
pouco mais geral, mas sua principal vantagem é que ele é mais fácil de escrever código multi-plataforma de usá-lo.
sistema se comporta de forma diferente no Windows a partir de outros sistemas operacionais (porque a chamada de API C desse nome faz).
Em outra parte ele invoca um shell para executar o comando: a porta do Windows de R tem uma função Concha fazer isso.
Para saber se o sistema operacional inclui um comando, o uso Sys.which, que tenta fazer isso de uma forma multi-plataforma (infelizmente,
não é um serviço padrão do sistema operacional).
Função shQuote citá filepaths conforme necessário para comandos no sistema operacional atual.
14,4 compressão e Arquivos

As versões recentes do R tem amplas instalações para ler e gravar arquivos compactados, muitas vezes de forma transparente. Leitura de
arquivos em R é, em grande medida vey feito por conexões, e a Arquivo função que é usado para abrir uma conexão com um arquivo (ou
uma URL) e é capaz de identificar a compressão utilizada a partir do cabeçalho 'magia' do arquivo.
O tipo de compressão que tem sido apoiado por mais longo que é gzip compressão, e que continua a ser um bom
compromisso geral. Arquivos compactados pelo Unix cedo comprimir utilitário também pode ser lido, mas estes estão se
tornando raros. Duas outras formas de compressão, aqueles do
Capítulo 14: instalações OS 81
bzip2 e xz utilidades também estão disponíveis. Estes geralmente alcançar maiores taxas de compressão (dependendo do arquivo, muito
mais elevados) em detrimento de descompressão mais lento e compressão muito mais lento.
Há alguma confusão entre xz e lzma compressão (ver https: //en.wikipedia. org / wiki / Xz e https://en.wikipedia.org/wiki/LZMA):
R pode ler arquivos compactados pela maioria das versões de ambos.
arquivos de ficheiros são únicos arquivos que contêm uma coleção de arquivos, as mais comuns sendo 'tarballs' e arquivos zip como
usado para distribuir pacotes de R. R pode listar e descompactar ambos (ver funções
untar e descompactar) e criar tanto (para fecho eclair com a ajuda de um programa externo).
82
sessão de exemplo AA Apêndice
A sessão seguinte se destina a apresentar-lhe algumas características do ambiente R, utilizando-os. Muitas características do
sistema será estranho e intrigante no início, mas esta confusão irá desaparecer em breve.
Comece R adequadamente para sua plataforma (ver Anexo B [Invocando R], página 85).
O programa R começa, com uma bandeira.
(No código de R, a linha do lado esquerdo não irá ser mostrado, para evitar confusão.)
help.start ()
Inicie a interface HTML a ajuda on-line (usando um navegador web disponível na sua máquina). Você deve
explorar brevemente as características deste mecanismo com o mouse. Minimizar a janela de ajuda e passar
para a próxima parte.
x <- rnorm (50) y <-

rnorm (x)
Gerar dois vectores normais pseudo-aleatório de X- e y- coordena.
trama (x, y)
Traçar os pontos no plano. A janela de gráficos aparecerá automaticamente.
ls () Veja quais objetos R estão agora no espaço de trabalho R.
RM (x, y) Remover objetos não são mais necessários. (Limpar).
x <- 01:20 Faço x = ( 1, 2, . . . , 20).
w <- 1 + sqrt (x) / 2

Um vector 'peso' de desvios padrão.
manequim <- data.frame (x = x, y = x + rnorm (x) * W) manequim

fazer uma quadro de dados de duas colunas, X e y, e olhar para ele.
fm <- lm (y ~ x, dados = simulado)

resumo (fm)
Caber uma regressão linear simples e olhar para a análise. Com y à esquerda do tilde, estamos modelando y dependente
de x.
fm1 <- lm (y ~ x, dados = manequim, peso = 1 / w ^ 2) síntese

(FM1)
Desde que nós sabemos os desvios-padrão, podemos fazer uma regressão ponderada.
attach (simulado)
Faça as colunas no quadro de dados visível como variáveis.
lrf <- Lowess (x, y)

Fazer uma função de regressão locais não paramétrico.
trama (x, y)
enredo ponto padrão.
linhas (x, y $ LRF)

Adicionar na regressão local.
abline (0, 1, LTY = 3)

A verdadeira linha de regressão: (interceptação 0, inclinação 1).
abline (coef (fm))

linha de regressão não ponderada.
Apêndice A: Uma sessão de exemplo 83
abline (coef (FM1), col = "vermelho")

linha de regressão ponderada.
separar () Remover quadro de dados do caminho de pesquisa.
trama (equipada (fm), resid (fm),

XLAB = "valores ajustados", ylab
= "Resíduos",
principal = "Resíduos vs cabido")
A trama de diagnóstico regressão padrão para verificar se há heterocedasticidade. você pode vê-lo?
qqnorm (resid (fm), principal = "Resíduos Rankit Plot")

A pontuação plot normal para verificar se há assimetria, curtose e valores discrepantes. (Não é muito útil aqui.)
RM (fm, FM1, LRF, x, simulado)

Limpar novamente.
A próxima seção irá olhar para os dados do experimento clássico de Michelson para medir a velocidade da luz. Este
conjunto de dados está disponível no Morley objeto, mas vamos lê-lo para ilustrar a read.table função.
filepath <- system.file ( "dados", "morley.tab", pacote = "conjuntos de dados") filepath Obter o caminho
para o arquivo de dados.
file.show (caminhoficheiro)
Opcional. Olhe para o arquivo.
mm <- read.table (filepath) mm

Ler os dados Michelson como um quadro de dados, e olhar para ele. Existem cinco experiências (coluna Experimento) e cada uma
delas tem 20 pistas (coluna Corre) e sl representa a velocidade de gravação da luz, adequadamente codificada.
mm $ Experimento <- fator (mm $ Experimento)
mm $ Run <- fator (mm $ Run)
mudança Experimento e Corre em factores.
anexar (mm)
Faça o quadro de dados visível na posição 3 (o padrão).
plot (Experimento, Velocidade, principal = "Velocidade de Dados Light", XLAB = "Experiment No.")
Compare os cinco experimentos com boxplots simples.
fm <- AOV (~ Run Velocidade + Experimento, data = mm) resumo

(fm)
Analisar como blocos ao acaso, com funcionamentos '' e '' experiências como factores.
FM0 <- atualização (fm, ~ -.. Run) anova

(FM0, fm)
Montar o sub-modelo omitindo 'corre', e comparar usando uma análise formal de variância.
separar () RM
(fm, FM0)
Limpar antes de prosseguir.
Vamos agora olhar para algumas características mais gráficas: contorno e imagem parcelas.
x <- SEQ (-pi, pi, len = 50) y <- x

X é um vector de valores 50 igualmente espaçadas em - π ≤ X ≤ π. y é o mesmo.
84
f <- exteriores (x, y, função (x, y) cos (y) / (1 + x ^ 2))

f é uma matriz quadrada, com linhas e colunas por indexados X e y respectivamente, dos valores da função cos
( y) / ( 1 + X 2).
oldpar <- par (no.readonly = TRUE) par (PTY = "s")
Salvar os parâmetros de traçagem e definir a região conspirar para “quadrado”.
contorno (x, y, f)
contorno (x, y, f, NLEVELS = 15, adicione = TRUE)
Faça um mapa de contorno de f; adicionar mais linhas para mais detalhes.
fa <- (ft (f)) / 2

fa é a “parte assimétrico” de f. ( t () é transpor).
contorno (x, y, FA, NLEVELS = 15)

Faça um gráfico de contorno,. . .
par (oldpar)
. . . e restaurar os velhos parâmetros gráficos.
imagem (x, y, f)
imagem (x, y, fa)
Faça algumas parcelas de imagem de alta densidade, (do qual você pode obter cópias impressas, se quiser),
. . .
objectos (); RM (x, y, f, fa)

. . . e limpar antes de prosseguir.
R pode fazer aritmética complexa, também.
th <- SEQ (-pi, pi, len = 100) z <- exp (1i *

th)
1i é usado para o número complexo Eu.
paridade (PTY = "s") trama

(z, type = "l")
Plotagem argumentos complexos significa trama imaginária contra partes reais. Este deve ser um círculo.
w <- rnorm (100) + rnorm (100) * 1i

Suponha que queremos provar pontos dentro do círculo unitário. Um método seria a de tomar números
complexos com partes reais e imaginárias normal padrão. . .
w <- ifelse (Mod (w)> 1, 1 / w, w)

. . . e mapear qualquer fora do círculo para o seu recíproco.
trama (w, = C xlim (-1,1), ylim = c (-1,1), PCH = "+", XLAB = "x", ylab = "Y") linhas (z) Todos os pontos estão
dentro do círculo unitário, mas a distribuição não é uniforme.
w <- sqrt (runif (100)) * exp (2 * pi * runif (100) * 1i)

trama (w, = C xlim (-1,1), ylim = c (-1,1), PCH = "+", XLAB = "x", ylab = "Y") linhas (z) O segundo método utiliza a distribuição
uniforme. Os pontos devem agora olhar mais
uniformemente espaçados ao longo do disco.
RM (th, w, z)
Limpar novamente.
q () Saia do programa de R. Você será perguntado se deseja salvar o espaço de trabalho R, e para uma sessão
exploratória como esta, você provavelmente não quer salvá-lo.
85
Apêndice B R Invocando
Usuários de R no Windows ou MacOS deve ler a seção específica do OS em primeiro lugar, mas o uso de linha de comando também é suportado.
B.1 Invocando R partir da linha de comando

Ao trabalhar em uma linha de comando em UNIX ou Windows, o comando ' R 'Pode ser usado tanto para o arranque do programa de P
principal sob a forma
R [ options] [<Infile] [> Outfile],

ou, através da R CMD interface, como um wrapper para várias ferramentas R (por exemplo, para o processamento de arquivos em formato de
documentação R ou manipular add-on pacotes) que não se destinam a ser chamado de “directamente”.
Na linha de comando do Windows, Rterm.exe é preferida a R.

Você precisa se certificar que tanto a variável de ambiente TMPDIR é unset ou ele aponta para um lugar válido para criar
arquivos e diretórios temporários.
A maioria das opções controlar o que acontece no início e no final de uma sessão de R. O mecanismo de inicialização é a
seguinte (ver também a ajuda on-line para o tópico ' Comece "Para mais informações, e a seção abaixo para alguns detalhes
específicos do Windows).
• A não ser que -- no-environ foi dado, R procura por arquivos do usuário e do site para processar para definir variáveis de
ambiente. O nome do arquivo de site é aquele apontado pela variável de ambiente R_ENVIRON; se este é definida, R_HOME
/ etc / Renviron.site é usada (se existir). O arquivo de usuário é aquele apontado pela variável de ambiente R_ENVIRON_USER
Se isso for definido; caso contrário, os arquivos. Renviron no atual ou no diretório home do usuário (nessa ordem) são
procurados. Esses arquivos devem conter linhas da forma ' name = valor '. (Vejo
ajudar ( "Startup") para uma descrição precisa.) Variáveis que você pode querer definir incluem R_ PAPERSIZE ( o tamanho de
papel padrão), R_PRINTCMD ( o comando de impressão padrão) e R_LIBS
(Especifica a lista de R árvores biblioteca procurou add-on pacotes).
• Então R procura o perfil de inicialização em todo o site, a menos que a opção de linha de comando - nosite-file foi dado. O
nome deste arquivo é retirado o valor do R_PROFILE
variável de ambiente. Se essa variável é definida, o padrão R_HOME / etc / Rprofile.site é utilizada, se esta existir.
• Então, a menos que - não-init-file foi dado, R procura por um perfil de usuário e fontes de TI. O nome deste arquivo é
retirado da variável de ambiente R_PROFILE_USER; Se não estiver definida, um arquivo chamado. Rprofile no diretório
atual ou no diretório home do usuário (nessa ordem) é procurado.
• Ele também carrega um espaço de trabalho salvo de arquivo. RDATA no diretório atual, se houver um (a menos - no-restaurar
ou - no-restore-dados foi especificada).
• Finalmente, se uma função. Primeiro() existe, ele é executado. Esta função (bem como. Último()
que é executada no final da sessão R) pode ser definido nos perfis de inicialização apropriadas, ou residir. RDATA.
Além disso, há opções para controlar a memória disponível para o processo de I (consulte a ajuda on-line para o tópico ' Memória '
Para maiores informações). Os usuários normalmente não precisa usar estes a menos que eles estão tentando limitar a quantidade de
memória usada por R.
R aceita as seguintes opções de linha de comando.
-- Socorro
-h Imprimir mensagem de ajuda curto para a saída padrão e sai.
- - versão
informações sobre a versão de impressão na saída padrão e sai.
Apêndice B: Invocando R 86
- - encoding = enc
Especificar a codificação a ser assumida para a entrada a partir da consola ou stdin. Isto precisa de ser conhecido para uma
codificação iconv: ver a sua página de ajuda. (- codificação enc também é aceito). A entrada é re-codificado para a região do R
está em execução e precisa ser representável na codificação deste último (assim por exemplo, você não pode re-codificar
texto grego em uma localidade francesa a menos que essa localidade usa a codificação UTF-8 ).
Rhome Imprimir o caminho para o diretório “home” R para a saída padrão e sai. Além do shell script front-end e a
página do manual, a instalação R coloca tudo (executáveis, pacotes, etc.) para este diretório.
-- Salve •
- - não-save
Controle se os conjuntos de dados devem ser salvos ou não no final da sessão R. Se nem é dado em uma
sessão interativa, o usuário é solicitado para o comportamento desejado quando terminar a sessão com q (); em
uso não interactivo um destes deve ser especificado ou implícita por alguma outra opção (ver abaixo).
- - no-environ
Não ler qualquer arquivo de usuário para definir variáveis de ambiente.
- - não-site-arquivo
Não leia o perfil de todo o site na inicialização.
- - não-init-file
Não leia o perfil do usuário na inicialização.
- - restaurar
- - no-restaurar
- - no-restore-dados
Controlar se as imagens guardadas (arquivo. RDATA no diretório onde R foi iniciado) devem ser restaurados na
inicialização ou não. O padrão é restaurar. (- no-restaurar
implica todo o específico - no-restore- * opções).
- - no-restore-história
Controlar se o arquivo de histórico (normalmente arquivo. Rhistory no diretório onde R foi iniciado, mas pode ser
definido pela variável de ambiente R_HISTFILE) devem ser restaurados na inicialização ou não. O padrão é
restaurar.
- - no-Rconsole
(Somente para Windows) impedir o carregamento do Rconsole arquivo na inicialização.
- - baunilha
Combine - sem salvar, --no-environ, --no-site-arquivo, --no-init-file e - norestore. No Windows, isso também inclui - no-Rconsole.
- f Arquivo
- - file = Arquivo
(não Rgui.exe) Pegar as informações de Arquivo: '-' significa stdin. implica - não-save a não ser que
- • Salve • foi definido. Em um Unix-alike, metacaracteres shell deve ser evitado em
Arquivo ( mas espaços são permitidos).
- e expressão
(não Rgui.exe) Usar expressão como uma linha de entrada. Um ou mais - e opções podem ser usadas, mas não em
conjunto com - f ou - Arquivo. implica - não-save a não ser que -- Salve • foi definido. (Existe um limite de 10.000 bytes
sobre o comprimento total de expressões utilizadas neste modo. Expressões contendo espaços ou metacharacters
concha terá de ser citado.)
- - no-readline
(UNIX apenas) Desligue a edição de linha de comando via Leia a linha. Isso é útil ao executar R de dentro
Emacs usando o ESS ( “Emacs Fala Estatísticas”) pacote. Consulte o Anexo C [O editor de linha de comando],
página 92, para mais informações. edição de linha de comando está habilitado para uso interativo padrão (ver - interativo).
Esta opção também afeta til expansão: veja a ajuda para path.expand.
- - min-vsize = N
- - min-nsize = N
Para uso perito só: definir os tamanhos iniciais de gatilho para a recolha de lixo amontoado de vector (em bytes) e células
(cons número), respectivamente. sufixo ' M 'Especifica megabytes ou milhões de células, respectivamente. Os padrões
são 6Mb e 350k, respectivamente, e também pode ser definido por variáveis de ambiente R_NSIZE e R_VSIZE.
- - max =-ppsize N
Especificar o tamanho máximo da pilha de protecção como ponteiro N Localizações. O padrão é 10000, mas
pode ser aumentada para permitir cálculos grandes e complicadas que ser feito. Atualmente, o valor máximo
aceito é 100000.
- - max-mem-size = N
(Somente para Windows) Especifique um limite para a quantidade de memória para ser usado tanto para
objetos R e áreas de trabalho. Esta é definida por defeito para a menor a quantidade de RAM física na máquina
e para 32 bits R, 1,5Gb 1, e deve estar entre 32Mb e o máximo permitido nessa versão do Windows.
- - quieto
-- silencioso
-q Não imprimir as mensagens iniciais de direitos autorais e de boas-vindas.
- - escravo Faça R correr o mais silenciosamente possível. Esta opção se destina a apoiar programas
que usar R para calcular resultados para eles. Isso implica -- quieto e - sem salvar.
- - interativo
(Apenas UNIX) afirmam que R realmente está sendo executada de forma interactiva, mesmo se a entrada foi
redireccionada: usar se a entrada é de uma FIFO ou tubo e alimentado a partir de um programa interactivo. (O padrão é
deduzir que R está sendo executado de forma interativa se e somente se stdin está ligado a um terminal ou Pty.) usando - e, -f
ou - Arquivo afirma uso não-interativo, mesmo se - interativo é dada.
Note que este não liga edição de linha de comando.
- - ess (Somente para Windows) Set Rterm -se para uso por R-inferior-mode em ESS, incluindo afirmando uso
interativo (sem o editor de linha de comando) e sem buffering de stdout.
- - verboso
Imprimir mais informações sobre o progresso, e em determinada opção set do R verboso para
VERDADE. código R utiliza esta opção para controlar a impressão de mensagens de diagnóstico.
- - depurador = nome
- d nome (Apenas UNIX) Executar R através depurador nome. Para a maioria dos depuradores (as exceções são
valgrind e as versões recentes do GDB), outras opções de linha de comando são ignorados, e deve
preferivelmente ser dada ao iniciar o R executável de dentro do depurador.
- - gui = tipo
- g tipo (Somente UNIX) Use tipo como interface gráfica do usuário (note que isso também inclui gráficos interativos).
Atualmente os valores possíveis para tipo está ' X11 '(O padrão) e,
1 2.5Gb em versões do Windows que suportam 3Gb por processo e têm o apoio habilitado: veja a rw-FAQ
Q2.9; 3.5GB na maioria das versões do Windows de 64 bits.

providenciou que ' Tcl / Tk 'Suporte está disponível,' Tk '. (Para back-compatibilidade " x11 'E' tk 'São aceitos.)
- - arch = nome
(Apenas UNIX) Execute o sub-arquitectura especificada.
- - args Esta bandeira não faz nada exceto causa o resto da linha de comando a ser ignorado: isso pode ser útil para
recuperar valores a partir dele com commandArgs (verdadeiro).
Note-se que a entrada e saída pode ser redirecionada da maneira usual (usando '<' e '>'), mas o limite de comprimento de linha
de 4095 bytes ainda se aplica. mensagens de aviso e erro são enviadas para o canal de erro ( stderr).
O comando R CMD permite a invocação de várias ferramentas que são úteis em conjunto com R, mas não destinados a ser
chamado “directamente”. A forma geral é
R CMD args comando
Onde comando é o nome da ferramenta e args os argumentos passados para ele.
Atualmente, as seguintes ferramentas estão disponíveis.
LOTE Execute R na modalidade de grupo. Corre R --restore --save possivelmente com mais opções (ver
? LOTE).
COMPILAR (Apenas UNIX) compilar C, C ++, Fortran. . . arquivos para uso com R.
shlib Construir biblioteca compartilhada para o carregamento dinâmico.
INSTALAR Instalar add-on pacotes.
REMOVER Remover pacotes add-on.
construir Construir (ou seja, pacote) add-on pacotes.
Verifica Confira pacotes add-on.
LIGAÇÃO (UNIX apenas) Front-end para a criação de programas executáveis.
Rprof Pós-processamento R perfil de arquivos.
Rdconv
Rd2txt Converter o formato Rd para vários outros formatos, incluindo HTML, L UMA TEX, texto simples e extrair os
exemplos. Rd2txt pode ser usado como uma abreviação para Rd2conv -t txt.
Rd2pdf Converter o formato Rd para PDF.
Stangle Extrair o código S / R do Sweave ou outra documentação vinheta
Sweave Processo Sweave ou outra documentação vinheta
rdiff saída ignorando Dif R cabeçalhos etc.
configuração Obter informações de configuração
javareconf
(Unix apenas) Atualize as variáveis de configuração Java
rtags (Unix apenas) Criar arquivos de marca Emacs-estilo de C, R, e arquivos Rd
abrir (Somente para Windows) Abra um arquivo via associações de arquivos do Windows'
texify (Somente para Windows) processo (La) TeX arquivos com arquivos de estilo de R Utilize
R CMD comando - Socorro
para obter informações de uso para cada uma das ferramentas acessíveis via R CMD interface.
Além disso, você pode usar as opções - = Arco, --no-environ, --no-init-file, --no-site-
Arquivo e - baunilha entre R e CMD: estas afetam todos os processos R executados pelas ferramentas. (Aqui
- - baunilha é equivalente a -- no-environ --no-site-arquivo --no-init-file). No entanto, note que R CMD não de si mesmo usar todos
os arquivos R inicialização (em particular, nem usuário nem local Renviron
arquivos), e todos os processos de I executados por estas ferramentas (excepto LOTE) usar -- no-restauração. Mais uso - baunilha e
assim invocar nenhum arquivo R inicialização: as exceções atuais são Instalar, remover Sweave e shlib ( que usa - não-site-arquivo
--no-init-file).
R CMD args cmd
para qualquer outro executável cmd no caminho ou dado por um caminho absoluto: este é útil ter o mesmo ambiente como R ou os
comandos específicos executados sob, por exemplo, para executar ldd ou
pdflatex. No Windows cmd pode ser um um arquivo de lote ou executável, ou se tem extensão. sh
ou. pl o intérprete apropriado (se disponível) é chamado para executá-lo.
B.2 Invocando R no Windows

Há duas maneiras de executar R no Windows. Dentro de uma janela do terminal (por exemplo, cmd.exe ou uma concha mais capaz),
podem ser utilizados os métodos descritos na secção anterior, por invocar r.exe
ou mais directamente pela Rterm.exe. Para uso interativo, há um GUI baseado em console ( Rgui.exe).
O procedimento de inicialização no Windows é muito semelhante ao que sob UNIX, mas as referências ao diretório home
'precisam ser esclarecidos, como este não é sempre definido no Windows. Se a variável de ambiente R_USER é definido, que dá
ao diretório home. Em seguida, se a variável de ambiente CASA é definido, que dá ao diretório home. Após essas duas
configurações controláveis pelo usuário, R tenta encontrar definido sistema diretórios home. Ele primeiro tenta usar o diretório do
Windows "pessoal" (normalmente Meus documentos em versões recentes do Windows). Se isso falhar, e variáveis de ambiente HOMEDRIVE
e HOMEPATH são definidos (e eles normalmente são) estes definir o diretório home. Falhando todos aqueles, o diretório home é
levado para ser o diretório de partida.
Você precisa se certificar variáveis que tanto o ambiente TMPDIR, TMP e TEMP são ou não configurado ou um deles aponta
para um lugar válido para criar arquivos e diretórios temporários.
As variáveis de ambiente podem ser fornecidos como ' name = valor 'pares na linha de comando. Se há um argumento final. RDATA
( em qualquer caso) é interpretado como o caminho para o espaço de trabalho para ser restaurado: implica - restaurar e define o
diretório de trabalho para o pai do arquivo chamado. (Este mecanismo é utilizado para arrastar e largar e associação com
arquivo RGui.exe,
mas também trabalha para Rterm.exe. Se o arquivo nomeado não existir, ele define o diretório de trabalho se existe o diretório
pai.)
As seguintes opções de linha de comando adicionais estão disponíveis ao invocar RGui.exe.
- - MDI
- - SDI
- - no-MDI Controlar se Rgui funcionará como um programa de MDI (com janelas de criança múltipla
dentro de uma janela principal) ou um aplicativo SDI (com múltiplas janelas de nível superior para o console, gráficos e
pager). O cenário de linha de comando substitui a configuração do usuário de Rconsole Arquivo.
- - depurar Ativar o item de menu “Break para debugger” em Rgui, e desencadear uma pausa para o
depurador durante o processamento da linha de comando.
No Windows com R CMD você também pode especificar o seu próprio. bastão, .Exe, .sh ou. pl Arquivo. Ele será executado sob o
intérprete apropriado (Perl para. pl) com diversas variáveis de ambiente ajustado adequadamente, incluindo R_HOME, R_OSTYPE,
PATH, BSTINPUTS e TEXINPUTS. Por exemplo, se você já tem latex.exe em seu caminho, em seguida,
R CMD mydoc latex.exe

será executado L UMA TEX em mydoc.tex, com o caminho para Rs share / texmf macros anexado ao TEXINPUTS.
(Infelizmente, isso não ajudar com a construção MiKTeX de L UMA TEX, mas R CMD mydoc texify
vai trabalhar nesse caso.)
B.3 Invocando R sob MacOS

Há duas maneiras de executar R no MacOS. dentro de um Terminal.app janela invocando R, os métodos descritos na primeira
subsecção aplicar. Há também GUI baseado em console ( R.app) que, por defeito está instalado na aplicações pasta no seu
sistema. É uma aplicação standard double-clickable MacOS.
O procedimento de inicialização no MacOS é muito semelhante ao que sob UNIX, mas R.app não fazer uso de argumentos de
linha de comando. O diretório home "é o um dentro do R.framework, mas a inicialização e diretório de trabalho atual está definido
como o diretório home do usuário, a menos de um diretório de inicialização diferente é dada na janela de Preferências acessível a
partir de dentro da GUI.
Script B.4 com R

Se você quiser apenas para executar um arquivo foo.R de comandos R, a maneira recomendada é usar R CMD foo.R. LOTE Se você deseja executar este
no fundo ou como uma utilização trabalho em lotes instalações específicas do SO para fazê-lo: por exemplo, na maioria dos shells em sistemas operacionais
Unix-alike R CMD LOTE foo.R & executa um trabalho de fundo.
Você pode passar parâmetros para scripts de via argumentos adicionais na linha de comando: por exemplo (onde a exata
citando necessário dependerá do shell em uso)
R CMD LOTE "--args arg2 arg1" foo.R &
vai passar argumentos para um script que pode ser recuperado como um vetor de caracteres por
args <- commandArgs (verdadeiro)
Este é mais simples pelo front-end alternativa RSCRIPT, que pode ser invocado por
RSCRIPT foo.R arg1 arg2
e isso também pode ser usado para escrever arquivos de script executáveis como (pelo menos no Unix-alikes e, em alguns conchas do Windows)
# ! / Path / to / RSCRIPT args <-

commandArgs (TRUE)
. . .
q (status = <código de status de saída>)
Se este é inserido em um arquivo de texto runfoo e este é feito executável (por chmod 755 runfoo), ele pode ser invocado para
diferentes argumentos por
runfoo arg1 arg2
Para mais opções, veja ajudar ( "RSCRIPT"). Este escreve saída de R de stdout e stderr, e isso pode ser redirecionado da
maneira usual para o shell executando o comando.
Se você não quiser codificar o caminho para RSCRIPT mas tê-lo em seu caminho (que é normalmente o caso para um R instalado,
exceto no Windows, mas os usuários por exemplo MacOS pode precisar adicionar
/ / Local / bin usr para o seu caminho), uso
# ! / Usr / bin / env RSCRIPT

. . .
Pelo menos em Bourne e festança conchas, o #! mecanismo faz não permitir argumentos extras, como #!
/ Usr / bin / env RSCRIPT --vanilla.
Uma coisa a considerar é o que stdin () refere-se a. É comum para escrever scripts R com segmentos como
Chem <- digitalizar (n = 24)

91
3,10 3,40 3,40 2,90 3,70 3,70 2,80 2,50 2,40 2,40 2,70 2,20
3,37 3,03 3,03 5,28 28,95 3,77 3,40 2,20 3,50 3,60 3,70 3,70
e stdin () refere-se ao arquivo de script para permitir tal uso tradicional. Se você quiser se referir ao processo de stdin, usar " stdin" como
um Arquivo conexão, por exemplo, Scan ( "stdin", ...).
Outra maneira de escrever arquivos de script executáveis (sugerido por Fran Cois Pinard) é a utilização de um Aqui
documento gostar
# ! / Bin / sh
[Variáveis de ambiente pode ser definido aqui] R --slave [outras
opções] << EOF
programa R vai aqui ...
EOF
mas aqui stdin () refere-se à fonte do programa e " stdin" não será utilizável.
roteiros curtos podem ser passados para RSCRIPT na linha de comando através da a - e bandeira. (Roteiros vazios não são aceitos.)
Note-se que em um Unix-alike o nome do arquivo de entrada (como foo.R) não deve conter espaços nem metacaracteres shell.
92
Apêndice C O editor de linha de comando
C.1 Preliminares
Quando o GNU Leia a linha biblioteca está disponível no momento R é configurado para compilação em UNIX, um editor de linha de
comando embutido permitindo recordação, edição e re-envio de comandos anteriores é utilizado. Note-se que outras versões do Leia a
linha existe e pode ser usado pelo editor de linha de comando embutido: Isso costumava acontecer no MacOS.
Ela pode ser desativada (útil para uso com ESS 1) usando a opção de inicialização - no-readline.
A versões Windows do R ter um pouco mais simples edição de linha de comando: ver ' Console ' debaixo de ' Socorro "Menu da
GUI, eo arquivo README.Rterm para-line comando de edição sob Rterm.exe.
Quando se utiliza R com GNU 2 Leia a linha capacidades, as funções descritas abaixo estão disponíveis, bem como os outros
(provavelmente) documentado em homem readline ou informações readline em seu sistema.
Muitos destes usar tanto caracteres de controle ou meta. caracteres de controlo, tal como Controlo-m,
são obtidos mantendo o CTRL para baixo enquanto você pressiona o m chave, e são escritos como Cm abaixo. caracteres, tais como
meta Meta-b, são digitados pressionando META 3 e pressionando b, e escrito como Mb na sequência. Se seu terminal não tem uma META chave
habilitado, você ainda pode digitar caracteres Meta usando seqüências de dois caracteres começando com ESC. Assim, para introduzir Mb,
você pode digitar SEBC. o ESC sequências de caracteres também são permitidas em terminais com teclas Meta reais. Note que caso é
significativo para caracteres Meta.
Algumas, mas não todas as versões 4 do Leia a linha reconhecerá o redimensionamento da janela do terminal de modo que este é melhor evitar.
ações C.2 Edição

O programa R mantém um histórico das linhas de comando que você digita, incluindo as linhas erradas, e comandos em seu
histórico pode ser recordado, alterado se necessário, e re-submetidos como novos comandos. Na linha de comando Emacs-style
editar qualquer digitação reta você faz enquanto nesta fase de edição faz com que os caracteres a ser inserido no comando que
você está editando, deslocando quaisquer caracteres à direita do cursor. Em vi modo de inserção de caracteres modo é iniciado
por Mi
ou Ma, caracteres são digitados e modo de inserção está concluído digitando uma outra ESC. ( O padrão é Emacs-style, e apenas
que é descrito aqui: para vi modo de ver a Leia a linha documentação.)
pressionando o RET comando a qualquer momento faz com que o comando para ser re-submetidos. Outras ações
de edição são resumidas na tabela a seguir.
C.3 Command-line resumo editor
recordação de comando e movimento vertical
Cp Ir para o comando anterior (para trás na história).
Cn Ir para o próximo comando (para a frente na história).
texto Cr Encontrar o último comando com o texto corda nele. Este pode ser cancelada CG ( e
em algumas versões do R de Cc).
1O 'Emacs Fala Statistics' pacote; Veja o URL https://ESS.R-project.org/

2É possível construir R usando uma emulação do GNU Leia a linha, tais como um baseado em NetBSD editline, ele que
caso, apenas um subconjunto das capacidades podem ser proporcionados.

3 Em um teclado PC esta é geralmente a tecla Alt, ocasionalmente, a chave 'Windows'. Em um teclado Mac normalmente
nenhuma tecla meta está disponível.

4 Em particular, não versões 6.3 ou posteriores: este é contornado a partir de R 3.4.0.
Apêndice C: O editor de linha de comando 93
Na maioria dos terminais, você também pode usar a cima e para baixo teclas de seta em vez de Cp e Cn,
respectivamente.
movimento horizontal do cursor

Ca Vá para o início do comando.
Ce Vá para o final da linha.
Mb Volte uma palavra.
mf Vá em frente uma palavra.
Cb Volte um personagem.
Cf Vá em frente um personagem.
Na maioria dos terminais, você também pode usar as teclas de seta esquerda e direita em vez de Cb e Cf,
respectivamente.
Edição e re-submissão
texto Inserir texto no cursor.
texto Cf Acrescentar texto após o cursor.
DEL Excluir o caractere anterior (à esquerda do cursor).
CD Excluir o caractere sob o cursor.
Md Excluir o restante da palavra sob o cursor, e “salvar”-lo.
Ck Excluir do cursor até o fim de comando e “salvar”-lo.
Cy Insira (yank) o último “salvo” texto aqui.
Ct Transpor o carácter sob o cursor com o próximo.
ml Alterar o resto da palavra para minúsculas.
Mc Alterar o resto da palavra em maiúsculas.
RET Re-enviar o comando para R. A final RET termina a sequência de edição de linha de comando. o Leia a linha teclas
pode ser personalizado da maneira usual através da um ~ /. inputrc file. These customizations can be conditioned on
application R, that is by including a section like
$if R
"\C-xd": "q(’no’)\n" $endif
94
Appendix D Function and variable index
! ?
!..................................................9 ? 4
!= . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9 ?? 4
% ^
%*% . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
^ 8
%o% . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
&
&..................................................9 9
&&. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40 40
* ~
* .................................................. 8
~ 52
+
A
+.................................................. 8
ab ne 66
ace 61
– add1 56
anova 54 55
- .................................................. 8
aov 55
ape m 21
. a ay 20
as da a ame 27
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
as vec o 24
. First . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
a ach 28
. Last . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
a 14
a bu es 14
avas 61
/ ax s 67
/..................................................8
B
:
boxp o 37
:..................................................8
b eak 41
::. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78
buo 61
78
< C
< 9 c 7 10 24 27
<< 47 cb nd 24
<= 9 coe 54
coe c en s 54
con ou 65
= con as s 53
== 9 cop o 64
cos 8
c ossp od 19 22
> cu 25
C 53
> 9
>= 9
Appendix D: Function and variable index 95
D K
data . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31 ks es 36
data.frame . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
density . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
det . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23 L
detach . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28 egend 66
determinant . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23 eng h 8 13
dev.list . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75 eve s 16
dev.next . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75 nes 66
dev.off . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75 s 26
dev.prev . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75 m 54
dev.set . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75 me 61
deviance . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54 oca o 68
diag . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22 oess 61
dim
d m . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
og 8
do cha 65
qs 61
d op1 56
s 23
E M
ecd 35 ma s 61
ed 32 max 8
e gen 23 mean 8
e se 40 me hods 49
E o 55
mn 8
examp e 4
mode 13
exp 8
N
F
NaN 9
ac o 16 NA 9
FALSE 9 nco 22
venum 34 nex 41
o 40
nm 59 60 61
o mu a 54
n me 61
unc on 42
n m nb 59
F 9
n ow 22
G O
ge Anywhe e 49
op m 59
ge S3me hod 49
o de 8
gm 57
o de ed 17
ou e 21
H
he p 4 P
he p sea ch 4
pa s 64
he p s a 4
pa 68
hs 34 64
pas e 10
pd 74
I pe sp 65
po 54 63
den y 68 pmax 8
40 pm n 8
e se 40 png 74
mage 65 po n s 66
s na 9
po ygon 66
s nan 10
pos sc p 74
p ed c 54
J p n 54
p od 8
peg 74
Appendix D: Function and variable index 96
Q summa y 34 54
svd 23
qqline . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35, 64
qqnorm . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35, 64
qqplot . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64 T
qr. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
21
quartz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74
es 37
ab e 20 25
R an 8
app y 16
range . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8 ex 66
rbind . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24 e 67
read.table . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30 ee 62
rep. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9 T 9
repeat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41 TRUE 9
resid . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
residuals. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
rlm
m . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61 U
m 6 unc ass 14
upda e 55
S
scan 31 V
sd 17 va 8 17
sea ch 29 va es 38
seq 8 vcov 55
shap o es 36 vec o 7
sn 8
s nk 5
so ve 22 W
so 8 wh e 41
sou ce 5 w cox es 38
sp 40 w ndows 74
sq 8
s em 34
s ep 54 56
X
sum 8 X11 74
97
Appendix E Concept index
A K
Accessing builtin datasets . . . . . . . . . . . . . . . . . . . . . . . . 31 Additive models . . . . . .Ko
. . .mogo
. . . . .ov
. . Sm
. . . .nov
. . . .es
. 36
. . . . . . . . . 61 Analysis of variance . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55 Arithmetic functions and
operators . . . . . . . . . . . . . . . . 7 Arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18 Assignment . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7 Attributes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
L
Leas squa es ng 23 L nea equa ons
22 L nea mode s 54 L s s
26 Loca app ox ma ng eg ess ons 61 Loops and
cond ona execu on 40
B
Binary operators . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43 Box plots. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
37
M
C
Ma ces 18 Ma x mu p ca on
Character
Charac
Cha ac e vec
vectors.
o s . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10 C
Classes
asses . . . . . . . . . . 22
. . .Max
. . . .mum
. . . . .ke
. . .hood
. . . . . . . . . . . . . . 14
14, 61 M ss ng va ues
48 Conca ena ng s s 27 Con as s
9 M xed mode s 61
53 Con o s a emen s 40 CRAN
77 Cus om z ng he env onmen 48
N
Named a gumen s 43 Namespace
D 78 Non nea eas squa es 59
Da a ames 27 De au va ues
43 Dens y es ma on 34 De e m nan s
23 D ve ng npu and ou pu 5 Dynam c g aph cs
76 O
Ob ec o en a on 48 Ob ec s
13 One and wo samp e es s 36 O de ed ac o s
16 53 Ou e p oduc s o a ays 21
E
E genva ues and e genvec o s 23 Emp ca CDFs
35
P
F Packages 2 77 P obab y d s bu ons
Fac o s 16 53 Fam es 33
57 Fo mu ae 51
Q
G QR decompos on 23 Quan e quan e p o s
35
Gene a zed nea mode s 56 Gene a zed anspose o an
a ay 21 Gene c unc ons 48 G aph cs
dev ce d ve s 74 G aph cs pa ame e s
68 G ouped exp ess ons 40 R
Read ng da a om es 30 Recyc ng u e
7 20 Regu a sequences 8 Remov ng ob ec s
6 Robus eg ess on 61
I
ndex ng o and by a ays 18 ndex ng vec o s
10
Appendix E: Concept index 98
S U
Scope . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46 Search path . . . . .Updating
. . . . . . . fitted
. . . . .models
. . . . . ................................ . . . . . . . . . . . 55
29 Shapiro-Wilk test. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36 Singular value decomposition . . . .
. . . . . . . . . . . . . . . . . 23 Statistical models . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51 Student’s t test . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . 37 V
Vectors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
W
T Wilcoxon
W coxon test
es . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38 Wo
Workspace
kspace . . . . . . . . . . . . . . . . . . . . . .
Tabulation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25 Tree-based models 5
. .W
. . . .ng
. . .unc
. . . ons
................. 42
. . . 62
99
Appendix F References
D. M. Bates and D. G. Watts (1988), Nonlinear Regression Analysis and Its Applications. John Wiley & Sons, New York.
Richard A. Becker, John M. Chambers and Allan R. Wilks (1988), The New S Language. Chapman & Hall, New York. This book
is often called the “ Blue Book ”. John M. Chambers and Trevor J. Hastie eds. (1992), Statistical Models in S. Chapman & Hall,
New York. This is also called the “ White Book ”. John M. Chambers (1998) Programming with Data. Springer, New York. This is
also called the “ Green Book ”.
A. C. Davison and D. V. Hinkley (1997), Bootstrap Methods and Their Applications, Cambridge University Press.
Annette J. Dobson (1990), An Introduction to Generalized Linear Models, Chapman and Hall, London.
Peter McCullagh and John A. Nelder (1989), Generalized Linear Models. Second edition, Chapman and Hall, London. John A.
Rice (1995), Mathematical Statistics and Data Analysis. Second edition. Duxbury Press, Belmont, CA.
S. D. Silvey (1970), Statistical Inference. Penguin, London.

Uma Introdução Ao R (PT-BR)

Diunggah oleh

Informasi Dokumen

Judul Asli

Hak Cipta

Format Tersedia

Bagikan dokumen Ini

Bagikan atau Tanam Dokumen

Opsi Berbagi

Apakah menurut Anda dokumen ini bermanfaat?

Apakah konten ini tidak pantas?

Hak Cipta:

Format Tersedia

Uma Introdução Ao R (PT-BR)

Diunggah oleh

Hak Cipta:

Format Tersedia

Uma Introdução ao R

Notas sobre R: um ambiente de programação para análise de dados e gráficos

WN Venables, DM Smith ea R Core Team

2 man pu ações s mp es; números e vectores. . . . . . . . . . . . . . . . . 7

3 ob etos, seus modos e atr butos. . . . . . . . . . . . . . . . . . . . . . . . . 13

4 ordenadas e não ordenadas factores. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16

5 matr zes e matr zes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18

5.7.2 equações lineares e inversão. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22

6 Lista e quadros de dados. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26

7 Dados e tura de arqu vos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30

8 As d s r bu ções de probab dade 33

9 Agrupamento, oops e execução cond c ona . . . . . . . . . . . . . . . . . 40

10 Escrevendo suas própr as funções. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42

12 proced mentos gráf co. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63

14 nsta ações OS. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79

sessão de exemp o AA apênd ce. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82

Apêndice C O editor de linha de comando. . . . . . . . . . . . . . . . . . . . . . . . 92

Função D apênd ce e índ ce var áve . . . . . . . . . . . . . . . . . . . . . 94

Apênd ce índ ce E Concept. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97

Esta introdução de R é derivado de um conjunto inicial de notas descrevendo o S e S-Plus

Sugestões para o leitor

• uma manipulação de dados eficaz e facilidade de armazenamento,

• um conjunto de operadores para cálculos em matrizes, em matrizes particulares,

• um grande coerente coleção, e integrado de ferramentas intermediárias para análise de dados,

1.2 software relacionados e documentação

preparado para fazer um pouco de trabalho para encontrá-lo.

1,4 o sistema de janelas e R

1.5 Uso R interactivamente

Em usando R em UNIX o procedimento sugerido para a primeira ocasião é a seguinte:

$ Mkdir work work

4. Para sair do programa R o comando é

1. Faça trabalhos o diretório de trabalho e iniciar o programa como antes:

1.6 Uma sessão introdutória

1.7 Obter ajuda com funções e características

> ajuda (resolver)

Experimentar ? help.search para detalhes e mais exemplos. Os exemplos de um tópico

de ajuda pode normalmente ser executado por

> exemplo( tópico)

A versões Windows do R ter outros sistemas de ajuda opcionais: uso

para mais detalhes.

1,8 comandos R, sensibilidade caso, etc.

1.9 Recall e correção dos comandos anteriores

1.10 A execução de comandos a partir de ou desviar saída para um arquivo

> fonte ( "commands.R")

> afundar ( "record.lis")

restaura-lo para o console mais uma vez.

1,11 permanência de dados e objectos removendo

o excesso e alguns vão usá-lo como o início da próxima linha.

Para remover objetos da função rm está disponível:

> RM (x, y, z, tinta, lixo, temp, foo, bar)

listagens no MacOS e Windows.

2 manipulações simples; números e vectores

2.1 Vetores e atribuição

> x <- c (10,4, 5,6, 3,1, 6,4, 21,7)

> atribuir ( "x", c (10,4, 5,6, 3,1, 6,4, 21,7))

> C (10,4, 5,6, 3,1, 6,4, 21,7) -> x

Quanto mais atribuição

> y <- c (x, 0, x)

aritmética 2.2 Vector

Veja Seção 6.2.1 [listas Concatenação], página 27.

soma ((x-média (x)) ^ 2) / (comprimento (x) -1)

darei NaN e um aviso, mas

sqrt (-17 + 0i)