Introdução ao R

Introdução ao RPrograma de Pós-Graduação em Modelagem Computacional da UFJF

Leonardo Goliatt

Departamento de Mecânica Aplicada e ComputacionalUFJF

[email protected]

v. 13.07

Leonardo Goliatt (MAC/UFJF) Introdução ao R v. 13.07 1 / 132

Programa

1 Interface R

2 Sintaxe R

3 Pacotes do R

4 Gráficos

5 Interface com outras linguagens

6 Análise de casos


Conteúdo1 Interface R2 Sintaxe R

Informações PreliminaresInformações PreliminaresSintaxe do RSímbolosVetoresInstruções de ControleFunçõesOperadoresEstruturas de dadosObjetos e Classes

3 Pacotes do RPacotes de dados e funções

4 GráficosGráficos no R

5 Interface com outras linguagensR e outras Linguagens de ProgramaçãoCombinando R com C e Fortran

6 Análise de casosAjuste de CurvasVazão da Represa de FurnasAnálise de Adubação da SojaUsando o ANOVAAnálise Granulométrica do SoloComputação Simbólica no R


Interface R

Conteúdo

1 Interface R


Interface R

O R e sua filosofia de trabalho

R pode ser definido como um ambiente de programação comferramentas para

manipulação de dadoscálculose apresentação gráfica

Como ambiente, entende-se um sistema coerente e totalmente planejadoO R não é um software do tipo aplicativo

a preocupação não é com amigabilidade, mas comflexibilidadecapacidade de manipulação de dadosrealização de análises


Interface R

Sobre o R

R é freeR é open-source

Qualquer pessoa tem liberdade para usar e modficar

Quem usa R?GooglePfizerMerckBank of America

R possui mas de 1600 pacotes, entre eles:BiodiversityR (ecologia e meio ambiente)Emu (análise da fala)GenABEL (genoma humano)...

Deu no New York Times: http://nyti.ms/Wl12E4


http://nyti.ms/Wl12E4

Interface R

O que é o R?

R é um programa para análise estatística e representação gráfica.Funções e resultados de análises são armazenados como objetos,permitindo:

fácil modificação de funçõesconstrução de modelos

R é flexível e personalizávelIdeal para análise exploratória de dados

Por outro lado,R é pouco eficiente para manipular grandes conjuntos de dadosPouco eficiente na execução de grandes laços (loops) quandocomparado com outras linguagens com C, Fortran e C++Alternativas:

Pacotes de acesso a banco de dados (RMySQL)Uso de bibliotecas (escritas em C e Fortran) compiladas (R CMD SHLIB)


Interface R

Objetivos

Apresentar o ambiente de programação R contexto de simulação eanálise de dadosFornecer exemplos claros e simples da funcionalidade e flexibilidade doREstimular o aproveitamento do Software Livre, evitando as restrições desoftwares comerciais e o uso não autorizado destes.


Interface R

Página Oficial do R

Referência básica para usuários de R: http://www.r-project.org/inclui programas para downloadlistas de discussãodocumentação e ajuda

Livros:R in a NutshellThe Art of R Programming

Onde baixar (Linux, Windows, Mac):http://cran.fiocruz.br/

Ubuntu (Linux): sudo apt-get install r-base

Onde ober ajuda:R mailing listStack Overflow www.stackoverflow.com


http://www.r-project.org/

http://cran.fiocruz.br/

www.stackoverflow.com

Interface R

Como usar o R?

Diretamente do terminal ou console (tela preta)Linux: konsole, xterm, gnome-terminal

Usando interfaces gráficasRstudio: http://rstudio.org/Rkward: http://rkward.sourceforge.net/Rcmdr: http://www.rcommander.com/StatET: http://www.walware.de/goto/statet/Outras interfaces: http://www.sciviews.org/_rgui/


http://rstudio.org/

http://rkward.sourceforge.net/

http://www.rcommander.com/

http://www.walware.de/goto/statet/

http://www.sciviews.org/_rgui/

Interface R

Invocando o R na linha de comando

Se estiver corretamente instalado, abra um terminal e digite R.O símbolo “>” indica que o R está esperando um comando


Interface R


1> R version 2.13.1 (2011-07-08)

2> Copyright (C) 2011 The R Foundation for Statistical Computing

3> ISBN 3-900051-07-0

4> Platform: x86_64-pc-linux-gnu (64-bit)

5>

6> R é um software livre e vem sem GARANTIA ALGUMA.

7> Você pode redistribuí-lo sob certas circunstâncias.

8> Digite 'license()' ou 'licence()' para detalhes de distribuição.

9>

10> R é um projeto colaborativo com muitos contribuidores.

11> Digite 'contributors()' para obter mais informações e

12> 'citation()' para saber como citar o R em publicações.

13>

14> Digite 'demo()' para demonstrações, 'help()' para o sistema

15> de ajuda, ou 'help.start()' a ajuda em HTML no seu navegador.

16> Digite 'q()' para sair do R.


Interface R


Ajuda sobre algo sobre o que se deseja

1> apropos('help') # busca por comandos similares

2> [1] "help" "help.request" "help.search" "help.start"

3> apropos('mean')

4> [1] "colMeans" "kmeans" "mean"

5> [5] "mean.Date" "mean.default" "mean.difftime"

6> [9] "mean.POSIXlt" "rowMeans" "weighted.mean"

Quando só se sabe o que procurar

1> help('mean') # help em modo texto

2> ?mean # o mesmo que help('mean')

3> help('mean',help_type='html') # help em modo html


Interface R


Para sair do programa, digite

1> quit()

2> Save workspace image? [y/n/c]: n


Sintaxe R

Conteúdo

2 Sintaxe R


Sintaxe R Informações Preliminares

Informações Preliminares

Tipos de dados:character (“Leonardo”)numeric (1.)integer (3)logical (TRUE or FALSE)vector (tipos homogêneos)list (parecidos vectors, mas heterogêneos)matrix

dataframe (a maior parte dos dados estarão em dataframes)factors→ Variáveis qualitativas que podem ser incluídas em modelosas.factor

missing values (NA)· · ·




Funcionamento básico:entre com uma expressão no console e digite <enter>a expressão é avaliada e o resultado impresso na tela

Note que �[1]� sempre acompanha qualquer resultado

1> # Isto éum comentário

2> 1 + 2 + 3

3> [1] 6

4> 1 + 2 * 3 # outro comentário

5> [1] 7

6> (1 + 2) * 3 # ...

7> [1] 9




R é case-sensitive: então A e a são símbolos diferentes e se referem adiferentes variáveisComandos diferentes são separados por ponto e vírgula “;”O conjunto de símbolos dependem do idioma e do sistema operacionalonde se roda o R (tecnicamente, o locale em uso)Todos os símbolos alfanuméricos são permitidos, incluindo “.” e “_”Comentários começam com “#”

1> #

2> A=2; a="banana"

3> print(A)

4> [1] 2

5> print(a)

6> [1] "banana"

7> #

8> .num=45; print(.num+1)

9> [1] 46




Como a maioria das linguagens de programação, R permite atribuirvalores a variáveisA operação de atribuição tem a sintaxe objeto recebe valorHá dois operadores que atribuem valores a um objeto dessa maneira

sinal de menor seguido de hífen: <-sinal de igual: =

1> # Os dois operadores de atribuição <- e = são equivalentes

2> a <- 2

3> f <- b = 5*a

4> print(a)

5> [1] 2

6> print(b)

7> [1] 10

8> print(f)

9> [1] 10




Uma forma de atribuição menos usada é valor atribuído a objeto

1> # Outra forma, menos usual é

2> "salsa" <-d <-e

3> print(d)

4> [1] "salsa"

5> print(e)

6> [1] "salsa"

7>

8> # Para saber mais

9> ?"="

10> ?"<-"




Em R, todo resultado é interpretado como um vetorO “[1]” indica o índice do vetorNo caso abaixo, os números entre colchetes indicam o índice do primeiroelemento de cada linha

1> # sequência de inteiros no intervalo [1,50]

2> 1:50

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

4> [23] 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41

5> [42] 42 43 44 45 46 47 48 49 50




1> # Usando o R como calculadora

2> 4+6

3> [1] 10

4> 3/2+1

5> [1] 2.6

6> 4*3**3 # potências são indicadas por ** ou ^

7> [1] 108

8> # Outras funções

9> sqrt(2)

10> [1] 1.414214

11> sin(pi) # os ângulos são interpretados em radianos

12> [1] 1.224606e-16 # zero!

13> sqrt(sin(45*pi/180))

14> [1] 0.8408964

15> log(1) # logaritmo neperiano (base e)

16> [1] 0

17> log(64,4) # base 4

18> [1] 3



Uso de scripts

Exemplo um script: exemplo.R

1> # exemplo.R

2> a<-3

3> b<-6

4> print(a+b)

Executando o script de dentro do R

1> source('exemplo.R')

Chamando o script via terminal

1> R -f exemplo.R


Sintaxe R Sintaxe do R

Sintaxe do R

Vamos começar com uma visão geral do RÈ possível escrever quase qualquer expressão em R como uma funçãoPorém, isso pode se tornar confuso e o R permite algumas sintaxesespeciaisA sintaxe básica envolve:

Constantesnúmeroscaracteressímbolos.

SímbolosOperadores

Operadores básicos e definidos pelo usuárioAtribuição



Sintaxe do RVetores numéricos

1> # Números são interpretados literalmente

2> 1.1

3> [1] 1.1

4> 2^1023

5> [1] 8.988466e+307

6>

7> # Valores em notação hexadecimal comecam com "0x"

8> 0x1

9> [1] 1

10> 0xFFFF

11> [1] 65535




1> # Qualquer número éinterpretado como ponto flutuante de dupla ←↩precisão

2> typeof(1)

3> [1] "double"

4> ?typeof # mais sobre a função typeof()

5> typeof(as(1,"integer")) # se deseja um inteiro, use a função ←↩"as"

6> [1] "integer"




1> # Limites de precisão

2> (2^1023 + 1) == 2^1023 # 2^1023 éo máximo de precisão

3> [1] TRUE

4> # Limites de tamanho

5> 2^1024

6> [1] Inf # o universo so existe até 2^1023

7>

8> # R suporta complexos, escritos como (real) + (imaginário)i

9> 0+1i ^ 2

10> [1] -1+0i

11> sqrt(-1+0i)

12> [1] 0+1i

13> exp(0+1i * pi)

14> [1] -1+0i




1> # A função sqrt() retorna um valor do mesmo tipo de entrada

2> sqrt(-1)

3> [1] NaN

4> Warning message:

5> In sqrt(-1) : NaNs produced

6> # O operador a:b retorna uma sequência de inteiros no ←↩intervalo [a,b]

7> 1:5

8> [1] 1 2 3 4 5

9> typeof(1:5)

10> [1] "integer"

11> # Para combinar um conjunto de números em um vetor, use a ←↩função c()

12> v <- c(173,12,1.12312,-93)

13> print(v)

14> [1] 173.00000 12.00000 1.12312 -93.0000000




1> # Em R, c se refere a função primitiva c(), porém você pode ←↩redefinitr c

2> c <- 3

3> c

4> [1] 3

5> # mesmo após redefinir c, você pode combinar números

6> v <- c(3,2,1)

7> v

8> [1] 3 2 1



Sintaxe do RCaracteres

1> # Um caracter contém texto entre duas aspas

2> y <- "abc"

3> y

4> [1] "abc"

5> length(y) # tamanho de y

6> [1] 1

7> mode(y) # equivalente a typeof()

8> [1] "character"

9>

10> # Um vetor de caracteres

11> z <- c("abc","29 88")

12> length(z)

13> [1] 2

14> mode(z)

15> [1] "character"



Sintaxe do RCaracteres

1> # Concatenação de caracteres ...

2> u <- paste("abc","de","f") # concatena as strings

3> u

4> [1] "abc de f"

5> # ... e separação (split)

6> v <- strsplit(u,".") # divide em função dos espaços

7> v

8> [[1]]

9> [1] "abc" "de" "f"

10> # Outra forma de concaternar ...

11> u <- paste("abc","de","f",sep=".") # usa . como separador

12> u

13> [1] "abc.de.f"

14> # ... e separar

15> strsplit(u,"")

16> [[1]]

17> [1] "a" "b" "c" "." "d" "e" "." "f"


Sintaxe R Símbolos

Símbolos

Um símbolo é um objeto que se refere a outro objeto

1> # Símbolo éo nome da variável em R

2> x1 <- 1

3> X1 <- 2

4> x1

5> [1] 1

6> X1

7> [1] 2

8> x1.1 <- 1

9> x1.1_1 <- 1

10> # Se necessário (!?), defina um símbolo assim:

11> "1+2=3" <- "hello"

12> "1+2=3"

13> [1] "hello"

14> # Nem todas as palavras são símbolos (palavras reservadas)

15> # -- if, else, repeat, while, function, for, in, next, break

16> # -- TRUE, FALSE, NULL, Inf, NaN, NA

17> # -- ...


Sintaxe R Símbolos

SímbolosFunções

Uma função é uma outra forma de atribuir valor a um símbolo

1> # Atribui a função vetorial c(x+1, y+1) ao símbolo f

2> f <- function(x,y) {c(x+1, y+1)}

3> f(1,2)

4> [1] 2 3

5> # Para visualizar o conteúdo de f

6> f

7> function(x,y) {c(x+1, y+1)}


Sintaxe R Símbolos

SímbolosFunções

1> # Visualizando o conteúdo da função desvio padrão

2> sd

3> function (x, na.rm = FALSE)

4> {

5> if (is.matrix(x))

6> apply(x, 2, sd, na.rm = na.rm)

7> else if (is.vector(x))

8> sqrt(var(x, na.rm = na.rm))

9> else if (is.data.frame(x))

10> sapply(x, sd, na.rm = na.rm)

11> else sqrt(var(as.vector(x), na.rm = na.rm))

12> }


Sintaxe R Vetores

VetoresOperações básicas

O comando c(), de “combinar”, é a forma principal de criar vetores

1> # Criando objetos

2> x<- c(1,2,3); print(x)

3> [1] 1 2 3

4> y<- 5:9; print(y) # aqui temos uma sequência

5> [1] 5 6 7 8 9

6> z<-c(x,y); print(z) # x e y são aglutinados em z

7> [1] 1 2 3 5 6 7 8 9

8> # Listando os elementos no espaço de trabalho

9> ls()

10> [1] "x" "y" "z"

11> # Apagando alguns deles

12> rm(x,y)

13> # Listando novamente

14> ls()

15> [1] "z"

16> rm(list=ls()) # apaga tudo


Sintaxe R Vetores


1> # soma de vetores

2> c(1,2,3) + c(1,1,1)

3> [1] 2 3 4

4> # se não têm o mesmo tamanho, a menor sequência érepetida

5> c(1, 2, 3, 4) + 1

6> [1] 2 3 4 5

7> # o mesmo vale para divisão

8> 1 / c(1, 2, 3, 4, 5)

9> [1] 1.0000000 0.5000000 0.3333333 0.2500000 0.2000000

10>

11> # no caso abaixo, a menor sequência tem tamanho 2

12> c(1, 2, 3, 4) + c(10, 100)

13> [1] 11 102 13 104


Sintaxe R Vetores


1> # A primeira sequência não émúltipla da segunda: 5 não é←↩mútiplo de 2

2> c(1, 2, 3, 4, 5) + c(10, 100)

3> [1] 11 102 13 104 15

4> Mensagens de aviso perdidas:

5> In c(1, 2, 3, 4, 5) + c(10, 100) :

6> comprimento do objeto maior não émúltiplo do comprimento do ←↩objeto menor

7> # Em R podemos entrar com expressões de caracteres

8> "Hello world."

9> [1] "Hello world."

10> # Um vetor de caracteres de comprimento 2

11> c("Hello world", "Hello R interpreter")

12> [1] "Hello world"

13> [2] "Hello R interpreter"


Sintaxe R Vetores


1> # Formas de acessar os membros de um vetor

2> b = c(1:10)

3> b

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

5> b[5] # acessa o 5o. elemento de b

6> [1] 5

7> b[2:7] # acessa uma fatia de b

8> [1] 2 3 4 5 6 7

9> b%%3 # resto da divisão por 3

10> [1] 1 2 0 1 2 0 1 2 0 1


Sintaxe R Vetores


1> # A operação abaixo retorna um vetor lógico

2> b%%3==0

3> [1] FALSE FALSE TRUE FALSE FALSE TRUE FALSE FALSE TRUE FALSE

4>

5> # Elementos de b congruentes de 0 (mod 3)

6> b[b%%3==0]

7> [1] 3 6 9

8> #

9> b[c(2,6,9)]

10> [1] 2 6 9


Sintaxe R Instruções de Controle

Instruções de Controle

As instruções de controle em R são muito similares àquelas de C, C++,Perl e PythonAqui vamos focar nos laços (loops) e condicionais (if-else)

1> # Python-like for: uma iteração para cada elemento

2> x <- c(5,12,13)

3> for (n in x){

4> + y = x/10

5> + print(n^2+y)

6> + }

7> [1] 25.5

8> [1] 144.12

9> [1] 169.13




As instruções de controle em R são muito similares àquelas de C, C++,Perl e PythonAqui vamos focar nos laços (loops) e condicionais (if-else)

1> # O mesmo vale para listas

2> l=list(p=21,k=c(1,2,3),z=NaN, f=function(a){return(a^2)})

3> for(x in l) print(x)

4> [1] 21

5> [1] 1 2 3

6> [1] NaN

7> function(a){return(a^2)}




1> # C-style while

2> i <- 1

3> while (i <= 10) i <- i+4

4> i

5> [1] 13

6>

7> # Funcionamento básico do if

8> if (r == 4) {

9> + x <- 1

10> +} else {

11> + x <- 3

12> + y <- 4

13> +}




1> # Duas formas de representar a mesma operação

2> x <- 1

3> y <- if(x == 2) x else x+1

4> y

5> [1] 2

6> if(x == 2) y <- x else y <- x+1

7> y

8> [1] 2


Sintaxe R Funções

Funções

Em R, as operações que fazem todo o trabalho são chamadas funções

1> # Funções com 1 argumento

2> exp(1)

3> [1] 2.718282

4> cos(3.141593)

5> [1] -1

6> # Alguns argumentos podem ser especificados pelo nome

7> log(x=64, base=4)

8> [1] 3

9> # O comando seq() possui vários argumento opcionais

10> seq(from=0,to=10,by=0.8) # intervalo

11> [1] 0.0 0.8 1.6 2.4 3.2 4.0 4.8 5.6 6.4 7.2 8.0 8.8 9.6

12> seq(from=0,to=10,length=20) # comprimento

13> [1] 0.0000000 0.5263158 1.0526316 1.5789474 2.1052632 2.6315789

14> [7] 3.1578947 3.6842105 4.2105263 4.7368421 5.2631579 5.7894737

15> [13] 6.3157895 6.8421053 7.3684211 7.8947368 8.4210526 8.9473684

16> [19] 9.4736842 10.000000


Sintaxe R Funções

Funções

Nem todas as funções têm a forma f (x1,x2, ....)

Algumas aparecem na forma de operadores

1> 17 + 2

2> [1] 19

3> 2 ^ 10

4> [1] 1024

5> 3 == 4

6> [1] FALSE


Sintaxe R Funções

Funções

Assim como em qualquer linguagem de programação, o cerne do Rconsiste em escrever funçõesUma função é um grupo de instruções que recebe as entradas, operasobre elas e retorma uma saída

1> # Conta o número de números ímpares em um vetor de inteiros

2> oddcount <- function(x)

3> + k <- 0 # o + indica continuação de linha

4> + for (n in x) {

5> + if (n %% 2 == 1) k

6> + }

7> + return(k) # o função retorna alguma coisa

8> + }

9>

10> oddcount(c(1,3,5))

11> [1] 3

12> oddcount(c(1,2,3,7,9))

13> [1] 4


Sintaxe R Funções

Funções

Variáveis criadas fora da função são globais e visíveis pela função

1> f <- function(x) return(x+y)

2> y <- 3

3> f(5)

4> [1] 8

Entradas podem ter um valor default

1> f <- function(x,y=10) return(x+y)

2> f(x=3)

3> [1] 13

4> f(x=3,y=3)

5> [1] 6

6> f(k=3)

7> Error in f(k = 3) : unused argument(s) (k = 3)


Sintaxe R Operadores

OperadoresOperadores básicos

Um operador é uma função que toma um ou mais argumentos e podeser escrita sem parênteses

1> x <- -1:5

2> x

3> [1] -1 0 1 2 3 4 5

4> # adição e multiplicação

5> 2 * x + 3

6> [1] 1 3 5 7 9 11 13

7> # exponenciação

8> x^3

9> [1] -1 0 1 8 27 64 125

10> # resto da divisão (módulo)

11> x %% 2 #-- éperiódico

12> [1] 1 0 1 0 1 0 1

13> # divisão inteira

14> x %/% 5 # x %/% 5 == floor(x/5)

15> [1] -1 0 0 0 0 0 1



OperadoresOperadores definidos pelo usuário

1> # Você pode definir seus próprios operadores

2> # Vamos definir o operador %myop% através de uma função

3> "%myop%" <- function(a, b) {2*a + b}

4> 1 %myop% 1

5> [1] 3

6> 1 %myop% 2

7> [1] 4

8> c(1,2,3,4,5) %myop% 2

9> [1] 4 6 8 10 12

10> # Atribuição éum operador

11> x <- c(1,2,3,4,5)

12> # O negativo também éum operador

13> -7

14> [1] -7

15> # O ponto de interrogação ? (help) também éum operador

16> ?"?"



OperadoresAtribuição

1> # As operações de atribuição atribuem um objeto a um símbolo

2> # Vetor atribuído a um símbolo

3> v <- c(1,2,3,4,5,6,7,8)

4> # Objeto lista atribuída a um símbolo

5> y <- list(sapato="mocassim", chapeu="gorro", camisa="polo")

6> y

7> $sapato

8> [1] "mocassim"

9> $chapeu

10> [1] "gorro"

11> $camisa

12> [1] "polo"

13> # Objeto função atribuído a um símbolo

14> z <- function(a,b,c) {a ^ b / c}

15> z

16> function(a,b,c) {a ^ b / c}


Sintaxe R Estruturas de dados

Introdução as estruturas de dados

Em R, podemos construir estruturas de dados mais complicadas do quevetoresAlguns casos

arrayslistasdataframes...



Estruturas de dadosArrays

1> # Um array éum vetor multidimensional

2> a <- array(c(1,2,3,4,5,6,7,8,9,10,11,12),dim=c(3,4))

3> a

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

5> [1,] 1 4 7 10

6> [2,] 2 5 8 11

7> [3,] 3 6 9 12

8> # Para acessar o elemento [2,2]

9> a[2,2]

10> [1] 5

11> # Veja como fica um vetor com o mesmo conteúdo

12> v <- c(1,2,3,4,5,6,7,8,9,10,11,12); v

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




1> # Relembrando do array a, podemos acessá-lo de diferentes formas

2> a

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

4> [1,] 1 4 7 10

5> [2,] 2 5 8 11

6> [3,] 3 6 9 12

7>

8> # Somente a primeira linha

9> a[1,]

10> [1] 1 4 7 10

11> # Somente a primeira coluna

12> a[,1]

13> [1] 1 2 3




1> # Acessando uma fatia das linhas

2> a[1:2,]

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

4> [1,] 1 4 7 10

5> [2,] 2 5 8 11

6> # Relembrando do array a mais uma vez

7> a

8> [,1] [,2] [,3] [,4]

9> [1,] 1 4 7 10

10> [2,] 2 5 8 11

11> [3,] 3 6 9 12




1> # Acessando um conjunto não contíguo colunas

2> a[,c(1,3)] # mostra somente as colunas 1 e 3

3> [,1] [,2]

4> [1,] 1 7

5> [2,] 2 8

6> [3,] 3 9

7>

8> # O sinal negativo exclui linhas ou colunas

9> a[-c(1,3),] # exclui linhas 1 e 3

10> [1] 2 5 8 11

11> a[-2,-c(1,4)] # exclui linha 2 e colunas 1 e 4

12> [,1] [,2]

13> [1,] 4 7

14> [2,] 6 9




1> # Uma matriz éum array bidimensional

2> m <- matrix(data=c(1,2,3,4,5,6,7,8,9,10,11,12),nrow=3,ncol=4)

3> m

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

5> [1,] 1 4 7 10

6> [2,] 2 5 8 11

7> [3,] 3 6 9 12

8>

9> # O comando matrix(() preenche as colunas com os dados ←↩fornecidos

10> matrix(1:6,nrow=2)

11> [,1] [,2] [,3]

12> [1,] 1 3 5

13> [2,] 2 4 6




1> # O preencimento por linhas também épossível

2> matrix(1:6,nrow=2, byrow=TRUE)

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

4> [1,] 1 2 3

5> [2,] 4 5 6

6>

7> # Uma outra forma de criar uma matriz éusando as funções

8> # -- rbind()

9> m <- rbind(c(1,4),c(2,-3))

10> m

11> [,1] [,2]

12> [1,] 1 4

13> [2,] 2 -3




1> # -- cbind()

2> n <- cbind(c(1,4),c(2,-3))

3> n

4> [,1] [,2]

5> [1,] 1 2

6> [2,] 4 -3

7>

8> # --diag()

9> diag(2)

10> [,1] [,2]

11> [1,] 1 0

12> [2,] 0 1




1> # Além da soma e subtração, temos as operações

2> # -- multiplicação termo a termo

3> m * diag(2)*3

4> [,1] [,2]

5> [1,] 3 0

6> [2,] 0 -9

7>

8> # -- divisão termo a termo

9> m/diag(2)

10> [,1] [,2]

11> [1,] 1 Inf

12> [2,] Inf -3




1> # -- produto matricial

2> m % * % n

3> [,1] [,2]

4> [1,] 17 -10

5> [2,] -10 13




Atenção!

1> # O R pode operar com arrays de diferentes tamanhos, por ←↩causa do reuso dos vetores!

2> x=matrix(1:6,ncol=2)

3> x

4> [,1] [,2]

5> [1,] 1 4

6> [2,] 2 5

7> [3,] 3 6

8> # Aparentemente, a operação não faria sentido

9> x+c(1,2)

10> [,1] [,2]

11> [1,] 2 6

12> [2,] 4 6

13> [3,] 4 8

14> # Vamos vamos fazer algumas considerações...




Atenção!

1> # Neste caso, ocorre a repetição dos valores, e a soma ←↩anterior éequivalente a

2> x + c(1,2,1,2,1,2)

3> [,1] [,2]

4> [1,] 2 6

5> [2,] 4 6

6> [3,] 4 8




Atenção!

1> # Observe a construção da matrix y, com c(1,2) repetido nas ←↩colunas

2> y=matrix(c(1,2,1,2,1,2),ncol=2)

3> y

4> [,1] [,2]

5> [1,] 1 2

6> [2,] 2 1

7> [3,] 1 2

8> x + y

9> [,1] [,2]

10> [1,] 2 6

11> [2,] 4 6

12> [3,] 4 8




1> # Arrays podem ter mais de uma dimensão

2> w <- array(c(1:18),dim=c(3,3,2))

3> print(w)

4> , , 1

5>

6> [,1] [,2] [,3]

7> [1,] 1 4 7

8> [2,] 2 5 8

9> [3,] 3 6 9

10>

11> , , 2

12>

13> [,1] [,2] [,3]

14> [1,] 10 13 16

15> [2,] 11 14 17

16> [3,] 12 15 18




1> # Acessando um dos elementos

2> w[1,1,1]

3> [1] 1



Estruturas de dadosListas

Uma lista aceita a mistura de objetos de diferentes tipos

1> # Uma lista contendo um número e uma string

2> e <- list(elemento="esfera", raio="8.25")

3> e

4> $elemento

5> [1] "esfera"

6> $raio

7> [1] "8.25"

8> # Os objetos podem ser acessados de várias formas

9> e$elemento

10> [1] "esfera"

11> e[2]

12> $raio

13> [1] "8.25"

14> e[[2]]

15> [1] "8.25"



Estruturas de dadosListas

1> # Uma lista pode referenciar outra lista

2> g <- list("Essa lista referencia outra lista", e)

3> g

4> [[1]]

5> [1] "Essa lista referencia outra lista"

6>

7> [[2]]

8> [[2]]$objeto

9> [1] "esfera"

10>

11> [[2]]$raio

12> [1] "8.25"



Estruturas de dadosDataframes

Um dataframe é um objeto que contém múltiplos vetores que são domesmo tamanho

é semelhante a uma planilha ou base de dadosbons para representar dados experimentais

1> # As 6 cidades mais populosas do Brasil

2> cidade <- c('São Paulo','Rio de ←↩Janeiro','Salvador','Brasília','Fortaleza', 'Belo ←↩Horizonte','Manaus')

3> estado <- c('SP','RJ','BA','DF','CE','MG','AM')

4> pop <- ←↩c(11376685,6390290,2710698,2648532,2500194,2395785,1861838)




Um dataframe é um objeto que contém múltiplos vetores que são domesmo tamanho

é semelhante a uma planilha ou base de dadosbons para representar dados experimentais

1> # As informações estão armazenadas em vetores

2> cidade

3> [1] "São Paulo" "Rio de Janeiro" "Salvador" "Brasília"

4> [5] "Fortaleza" "Belo Horizonte" "Manaus"

5> estado

6> [1] "SP" "RJ" "BA" "DF" "CE" "MG" "AM"

7> pop

8> [1] 11376685 6390290 2710698 2648532 2500194 2395785 1861838




1> # Armazenando em um dataframe

2> top6pop <-data.frame(cidade,estado,pop)

3> top6pop

4> cidade estado pop

5> 1 São Paulo SP 11376685

6> 2 Rio de Janeiro RJ 6390290

7> 3 Salvador BA 2710698

8> 4 Brasília DF 2648532

9> 5 Fortaleza CE 2500194

10> 6 Belo Horizonte MG 2395785

11> 7 Manaus AM 1861838




1> # Acessando as informações contidas em top6pop

2> top6pop$estado

3> [1] SP RJ BA DF CE MG AM

4> Levels: AM BA CE DF MG RJ SP

5> #

6> top6pop[2] # outra forma de acessar os estados

7> estado

8> 1 SP

9> 2 RJ

10> 3 BA

11> 4 DF

12> 5 CE

13> 6 MG

14> 7 AM




1> top6pop$pop > 2.7e6 # cidades com mais de 2.7 mi hab

2> [1] TRUE TRUE TRUE FALSE FALSE FALSE FALSE

3> #

4> top6pop$pop[top6pop$pop>2.7e6] # populações maiores que 2.7 ←↩mi hab

5> [1] 11376685 6390290 2710698


Sintaxe R Objetos e Classes

Objetos e Classes

R é uma linguagem orientada a objetosCada objeto em R tem um tipoE cada objeto em R é membro de uma classeJá encontramos diferentes classes: vetores de caracteres, vetoresnuméricos, dataframes, listas, ...

1> class(1:10)

2> [1] "integer"

3> class(w)

4> [1] "array"

5> class(v)

6> [1] "numeric"

7> class(top6pop)

8> [1] "data.frame"

9> class(e)

10> [1] "list"

11> class(class)

12> [1] "function"



Objetos e ClassesModelos e fórmulas

Um modelo é uma forma concisa de descrever um conjunto de dados,usualmente por meio de uma fórmula matemática

Algumas vezes o objetivo é construir um modelo preditivo baseado emdados disponíveis para avaliar novos dadosOutras vezes o objetivo é constrir um modelo descritivo que auxilie nomelhor entendimento dos dados

O R possui uma notação específica para decrever relações entrevariáveis

Suponha uma variável y onde assumimos uma dependência linear deoutras variáveis x1,x2, · · · ,xn, resultando no modelo

y = c1x1 + c2x2 + · · ·+ cnxn + ε

Em R, podemos escrever essa relação como um objeto fórmula

1> y ~ x1 + x2 + ... + xn




Vamos analisar o seguinte exemplo

1> # Conjunto de 20 pontos com ruído e distribuição normal

2> set.seed(2)

3> x = seq(from=0,to=5,length=20)

4> y = 2*x - 3 + rnorm(20) # rnorm(): distrib. normal

5> xy= data.frame(x,y)

6> xy

7> x y

8> 1 0.0000000 -3.8969145

9> 2 0.2631579 -2.2888350

10> ...

11> 20 5.0000000 7.4322652

12> # lm() constroi um modelo y~x e atribui a variável xy.lm

13> # -- y : variável dependente

14> # -- x : variável independente

15> xy.lm = lm(formula=y~x, data=xy)




1> # Vamos analisar o objeto xy.lm (modelo linear)

2> xy.lm

3>

4> Call:

5> lm(formula = y ~ x, data = xy)

6>

7> Coefficients:

8> (Intercept) x

9> -2.926 2.049

10>

11> # Observe os coeficiente e compare com o modelo y = 2*x - 3 + ←↩rnorm(20)




1> # Para maiores detalhes, use a função summary()

2> summary(xy.lm)

3> Call:

4> lm(formula = y ~ x, data = xy)

5>

6> Residuals:

7> Min 1Q Median 3Q Max

8> -2.57694 -0.45741 0.04638 0.62709 1.80821

9> Coefficients:

10> Estimate Std. Error t value Pr(>|t|)

11> (Intercept) -2.9261 0.4675 -6.259 6.65e-06 ***

12> x 2.0486 0.1598 12.816 1.74e-10 ***

13> ---

14> Signif. codes: 0 *** 0.001 ** 0.01 * 0.05 . 0.1 " " 1

15> Residual standard error: 1.085 on 18 degrees of freedom

16> Multiple R-squared: 0.9012, Adjusted R-squared: 0.8957

17> F-statistic: 164.3 on 1 and 18 DF, p-value: 1.738e-10




1> # predict.lm() avalia os dados do dataframe xy no modelo xy.lm

2> xy.pr=predict.lm(xy.lm)

3>

4> # Usamos algumas ferramentas gráficas para visualizar

5> plot(x,y,col='blue'); lines(x,xy.pr,col='red')


Pacotes do R

Conteúdo

3 Pacotes do R


Pacotes do R Pacotes de dados e funções

Pacotes de dados e funçõesIntrodução

Um pacote é um conjunto de funções, arquivos de ajuda e arquivos dedados empacotados juntosPacotes em R são similares aos modulos em Perl e Fortran, bibliotecasem C e classes em JavaTipicamente, todas as funções em um pacote estão relacionadas entre si

1> # Os pacotes de dados disponíveis são listados através

2> data()

3>

4> # Os pacotes de funçõesd isponíveis são listados usando

5> library()



Pacotes de dados e funçõesDados

O R possui pacotes de dados internos, usados principamente parademos e desenvolvimento de pacotes

1> # Os pacotes de dados disponíveis são listados através do ←↩comando

2> data()

3> Data sets in package 'datasets':

4>

5> AirPassengers Monthly Airline Passenger Numbers 1949-1960

6> BJsales Sales Data with Leading Indicator

7> ...

8> volcano Topographic Information on Maunga Whau Volcano

9> warpbreaks The Number of Breaks in Yarn during Weaving

10> women Average Heights and Weights for American Women

11>

12> Use "data(package = .packages(all.available = TRUE))"

13> to list the data sets in all *available* packages.




1> # Para acessar um determinado conteúdo

2> data(trees)

3> trees

4> Girth Height Volume

5> 1 8.3 70 10.3

6> 2 8.6 65 10.3

7> ...

8> 31 20.6 87 77.0




1> # Operando com os dados

2> class(trees)

3> [1] "data.frame"

4> mean(trees)

5> Girth Height Volume

6> 13.24839 76.00000 30.17097

7> str(trees) # mostra informações sobre a estrututa do ←↩objeto

8> 'data.frame': 31 obs. of 3 variables:

9> $ Girth : num 8.3 8.6 8.8 10.5 10.7 10.8 11 11 11.1 11.2 ...

10> $ Height: num 70 65 63 72 81 83 66 75 80 75 ...

11> $ Volume: num 10.3 10.3 10.2 16.4 18.8 19.7 15.6 18.2 22.6 ←↩19.9 ...




1> # Medidas do fluxo anual do Nilo na cidade de Ashwan 1871-1970

2> data(Nile)

3> Nile

4> Time Series:

5> Start = 1871

6> End = 1970

7> Frequency = 1

8> [1] 1120 1160 963 1210 1160 1160 813 1230 1370 1140 995 935

9> [13] 1110 994 1020 960 1180 799 958 1140 1100 1210 1150 1250

10> ...

11> [85] 918 986 797 923 975 815 1020 906 901 1170 912 746

12> [97] 919 718 714 740

13> str(Nile)

14> Time-Series [1:100] from 1871 to 1970: 1120 1160 963 1210 ←↩1160 1160 813 1230 1370 1140 ...

15> class(Nile) # objeto time series (série temporal)

16> [1] "ts"



Pacotes de dados e funçõesPacotes

O pacote stats agrupa funções de análise estatística

1> # Carrega os pacote -- comandos equivalentes

2> library(stats)

3> require(stats)

4>

5> # Para maiores informações

6> library(help="stats")

7> ?stats




R oferece um grande número de pacotesAnálise gráficaAplicações industriaisCiências sociais....

Alguns pacotes veem com o R, outros são instalados através derepositórios




1> # Pacotes carregados automaticamente

2> getOption("defaultPackages")

3> [1] "datasets" "utils" "grDevices" "graphics" "methods" "stats"

4> # Pacotes disponíveis para serem carregados

5> (.packages(all.available=TRUE))

6> [1] "ade4" "calibrate" "clusterSim" "corrgram"

7> [6] "Defaults" "ellipse" "gclus" "Hmisc"

8> [11] "nutshell" "quantmod" "R2HTML" "RColorBrewer"

9> [16] "seriation" "TSP" "TTR" "xts"

10> [21] "ape" "biclust" "bitops" "cba"

11> [26] "colorspace" "dataframes2xls" "e1071" "emoa"

12> # Instalação de pacotes -- repositórios online

13> install.packages('psy')

14> # Remoção de pacotes

15> remove.packages(c("tree", "maptree"),.Library)




1> # Exemplo de uso do pacote tsa (time series analysis)

2> Error in library(TSA) : there is no package called "tsa"

3> # Pacote não instalado

4>

5> # Instalação

6> install.packages('TSA')

7>

8> # Instalação completa

9> install.packages('TSA', dependencies=T)


Gráficos

Conteúdo

4 Gráficos


Gráficos Gráficos no R

Gráficos no R

R inclui vários pacotes para a visualização de dados

Se você é familiarizado com planilhas eletrônicas, vocÊ perceberá que oR pode gerar

gráficos de barrasgráficos de linhashistogramasgráficos de dispersão...

Vamos verificar alguns casos por meio de exemplos



Gráficos no R

1> # Gráfico da função seno

2> x = seq(0,1,0.1)

3> y = sin(2*pi*x)

4> plot(x,y,type='b',col='darkgreen',main='Função ←↩seno',xlab='eixo-x', ylab='eixo-y',lwd=2)



Gráficos no R

1> # Gráficos de funções paramétricas de uma variável

2> par(mfrow=c(1,2)) # uma linha e duas colunas

3> curve( 3*x^2+2*x+1, -1, 2,col="red",lwd=2)

4> curve(-3*x^2+2*x+1, -1, 2,col="blue",lwd=2)



Gráficos no R

1> # Histograma de uma série dados com distribuição normal

2> x = rnorm(1000)

3> hist(x,col="yellow",breaks=40)



Gráficos no R

1> # Um gráfico de barras

2> barplot(c(2,4,7,5,3,1),col='lightblue')



Gráficos no R

1> # Gráfico de pizza

2> pie(1:6, col = rainbow(6), labels= LETTERS[1:6], radius = 0.9)



Gráficos no R

1> # Gráfico de densidade

2> x = rnorm(200)

3> plot(density(x),col='red',lwd=2)



Gráficos no R

1> # Boxplots

2> x <- rnorm(200) # distribuição normal

3> y <- rlnorm(200) # distribuição log-normal

4> plot(x, y, xlim=c(-5,5), ylim=c(-2,8))

5> boxplot(x, col="gold" , horizontal=TRUE, at=-1, add=TRUE)

6> boxplot(y, col="blue", horizontal=FALSE, at=-4, add=TRUE)


Interface com outras linguagens

Conteúdo

5 Interface com outras linguagens


Interface com outras linguagens R e outras Linguagens de Programação

R e outras Linguagens de Programação

Em R, podemos reutilizar códigos desenvolvidos em outras linguagensR e C (ou C++)R e FortranR e Python (pacotes rpy, rpy2 e RSPython)R e Java (pacotes RJava e JRI)R e Perl (pacote RSPerl)R e MySQL (pacote RMySQL)


Interface com outras linguagens Combinando R com C e Fortran

Combinando R com C e Fortran

O R é relativamente lento em algoritmos iterativos que exigem laços(loops) repetidas vezesUma maneira de obter todas as vantagens de velocidade de C ouFortran com a maioria da conveniência de R é escrever o loop interno emC e chamá-lo de dentro do RVamos considerar um problema bem simples, elevar ao quadradooselementos de um vetor x = (x1,x2, . . . ,xn−1,xn)

q(x) = (x21 ,x

22 , . . . ,x

2n−1,x

2n )




Aqui temos o código em linguagem C com uma solução para o problemaO R exige duas proriedades da função:

A função não retorna nenhum valor. Todo o trabalho é feito mudando osvalores dos argumento.Todos os argumentos são ponteiros. Em R, mesmo escalares são vetores(de comprimento um).

1> /* pot2c.c */

2> void pot2c(int *nin, double *x)

3> {

4> int n = nin[0];

5> int i;

6>

7> for (i=0; i<n; i++)

8> x[i] = x[i] * x[i];

9> }




Aqui temos o a mesma função em uma subrotina em FortranEla tem as mesmas duas propriedades da função em C:

Ela não retorna valor, pois é uma subrotina. Funções (em Fortran) não sãoreconhecidas pelo R.A segunda proriedade é automática em Fortran. Fortran só aceitapassagens de argumentos por referência, que corresponde aos ponteirosem C.

1> ! pot2f.f

2> subroutine pot2f(n, x)

3> integer n

4> double precision x(n)

5> integer i

6>

7> do i = 1, n

8> x(i) = x(i) ** 2

9> enddo

10> end




A compilação para a geração de bibliotecas dinâmicas, é feita em umterminal Linux, e portanto fora do R (e usando o proprio R)

1> # Compila o código em C

2> R CMD SHLIB pot2c.c

3> # Resultado do comando

4> # gcc -I/usr/share/R/include -fpic -std=gnu99 -O3 -pipe -g ←↩-c pot2c.c -o pot2c.o

5> # gcc -shared -o pot2c.so pot2c.o -L/usr/lib/R/lib -lR

6>

7>

8> # Compila o código em Fortran

9> R CMD SHLIB pot2f.f

10> # Resultado do comando

11> # gfortran -fpic -O3 -pipe -g -c pot2f.f -o pot2f.o

12> # gcc -shared -o pot2f.so pot2f.o -lgfortran -lm -lquadmath ←↩-L/usr/lib/R/lib -lR

Se a compilação funcionar corretamente, serão gerados os arquivos�pot2c.so� e �pot2f.so�




Voltando ao R, podemos carregar as bibliotecas

1> # Carregas as biblotecas geradas

2> dyn.load("pot2c.so")

3> dyn.load("pot2f.so")

4>

5> # Verifica as bibliotecas carregadas com o comando ←↩getLoadedDLLs()

6> getLoadedDLLs()

7> Filename ←↩Dynamic.Lookup

8> base base FALSE

9> methods /usr/lib/R/library/methods/libs/methods.so FALSE

10> grDevices /usr/lib/R/library/grDevices/libs/grDevices.so FALSE

11> stats /usr/lib/R/library/stats/libs/stats.so FALSE

12> pot2c /tmp/pot2c.so TRUE

13> pot2f /tmp/pot2f.so TRUE




Executando o função em C

1> # Para testar, vamos criar um vetor x

2> x=c(1,2,3,4,5)

3> x

4> [1] 1 2 3 4 5

5>

6> typeof(x) # x deve ser double, assim como o argumento ←↩na função em C

7> [1] "double"

8>

9> # A chamada da função em R éfeita pelo comando .C()

10> .C("pot2c", n=length(x), x=x)

11> $n

12> [1] 5

13>

14> $x

15> [1] 1 4 9 16 25




Executando o subrotina em Fortran

1> # A chamada da subrotina em R éfeita pelo comando .Fortran()

2> .Fortran("pot2f", n=length(x), x=x)

3> $n

4> [1] 5

5>

6> $x

7> [1] 1 4 9 16 25



Combinando R com C e FortranUma solução mais agradável é criar uma função envelope

Permite checar alguns erros em R, o que é mais fácil que em CPermite que alguns argumento calculados não sejam mostradosPermite retornar somente o que o necessário

1> # Função envelope

2> pot2c <- function(x) {

3> if (!is.numeric(x))

4> stop("O argumento x deve ser numérico")

5> out <- .C("pot2c",

6> n=as.integer(length(x)),

7> x=as.double(x))

8> return(out$x)

9> }

10>

11> # Executando a função

12> pot2c(x)

13> [1] 1 4 9 16 25


Análise de casos

Conteúdo

6 Análise de casos


Análise de casos Ajuste de Curvas

Ajuste de Curvas

Vamos usar dados que relacionam a temperatura em graus Celsius como valor da pressão de mercúrio.

1> # Carrega os dados

2> data(pressure)

3> head(pressure)

4> temperature pressure

5> 1 0 0.0002

6> 2 20 0.0012

7> 3 40 0.0060

8> 4 60 0.0300

9> 5 80 0.0900

10> 6 100 0.2700

11>

12> pres = pressure$pressure # cria variáveis auxiliares

13> temp = pressure$temperature

14> plot(pres~temp, ylim=c(-50,400)) # gráfico dos dados



Ajuste de Curvas

1> # Constrói os modelos

2> lm1=lm(pres~temp) # linear

3> lm2=lm(pres~temp + I(temp^2)) # quadrático

4> lm3=lm(pres~temp + I(temp^2)+ I(temp^3)) # cúbico

5>

6> summary(lm1)

7> summary(lm2)

8> summary(lm3)

9>

10> # Gráficos dos modelos

11> plot(pres~temp, ←↩ylim=c(-50,400),xlab='Temperatura',ylab='Pressão')

12> lines(predict(lm1)~temp,col='green')

13> lines(predict(lm2)~temp,col='red')

14> lines(predict(lm3)~temp,col='blue')

15> # Legenda

16> legend(x='topleft',legend=c('linear','quadrático','cúbico'), ←↩col=c(3,2,4), lwd=1)



Ajuste de Curvas


Análise de casos Vazão da Represa de Furnas

Vazão da Represa de Furnas

Análise gráfica da série histórica (1931-2010) da vazão natural mensalda represa de FurnasFonte: http://www.ons.org.br/operacao/vazoes_naturais.aspxPlanilha eletrônica contendo as séries de vazões naturais médiasmensais


http://www.ons.org.br/operacao/vazoes_naturais.aspx



1> # Análise da série histórica das vazões mensais da barragens ←↩de Furnas

2> # Fonte: http://www.ons.org.br/operacao/vazoes_naturais.aspx

3> rm(list=ls()) # apaga todo o workspace

4> print(getwd()) # onde estamos?

5>

6> # Dados das vazões na planilha

7> # "Vazoes_Mensais_1931_2010.xls"

8> library(gdata) # suporte para leitura de planilhas

9> v <- read.xls(xls='./data/Vazoes_Mensais_1931_2010.xls',sheet=1)

10> View(v)

11>

12> ano <- v["ANO"] # primeira coluna

13> vaz <- v[,-1] # todos os dados exceto a 1a coluna

14>

15> # Aplica a função média nas colunas de v

16> vaz.m <- apply(vaz,2,mean) # médias das vazões mensais

17> View(vaz.m)




1> # Análise gráfica das médias das vazões mensais

2> bp <- barplot(vaz.m, ylim=c(0,1.2*max(vaz.m)), ←↩col="seagreen", ylab="Vazão", las=3)

3> text(bp, vaz.m, label=round(vaz.m, 0), pos=3,srt=90, cex=0.8, ←↩offset=1.5)

4> title("Médias mensais das vazões de Furnas"); box()




1> # Boxplots das vazões mensais

2> boxplot(vaz, las=3, col="steelblue", notch=1, ylab="Vazão", ←↩main="Vazões mensais de Furnas")

3> points(vaz.m, col='red', lwd=1, pch=19)

4> lines(vaz.m, col='red', lwd=1)




1> # Histograma das vazões mensais

2> vaz.t <- unlist(vaz)

3> hist(vaz.t,breaks=20,freq=F,ylim=c(0,12e-4), ←↩ylab='Densidade', xlab='Vazão',

4> main='Histograma das Vazões', col='lightblue')

5> lines(density(vaz.t), col='red'); rug(vaz.t, col='red')


Análise de casos Análise de Adubação da Soja

Análise de Adubação da Soja

Experimento em casa de vegetação com a cultura da soja, 2 plantas porparcela com:

3 níveis do fator conteúdo de do solo água (agua),5 níveis do fator adubação potássica (potassio),parcelas arranjadas em 5 blocos (bloco).

Foram observadas as seguintes variáveis:1 rengrao : redimento de grãos2 pesograo : peso de grãos3 kgrao : conteúdo de potássio no grão4 pgrao : conteúdo de fósforo no grão5 ts : total de sementes por planta6 nvi : número de vagens inviáveis7 nv : número de vagens total

Fonte: http://www.leg.ufpr.br/~walmes/


http://www.leg.ufpr.br/~walmes/



1> # Leitura dos dados no arquivo "soja.txt" que encontra-se no ←↩diretório "data"

2> #

3> # Primeiro, devemos saber em que diretório estamos

4> getwd()

5> # Depois, devemos mudar para o diretório onde estão os dados

6> setwd('diretorio_onde_estao_os_dados')

7> #

8> # O comando read.table() lê o arquivo em formato de tabela e ←↩cria um

9> # dataframe a partir dele, com as entradas correspondendo às ←↩linhas

10> # e as variáveis correspondendo às colunas

11> #

12> soja <- read.table('./data/soja.txt',header=TRUE)




1> View(soja) # visualização dos dados

2>

3> # Algumas informações sobre os dados

4> class(soja) # classe do objeto

5> names(soja) # nomes das colunas

6> dim(soja) # dimensões

7> str(soja) # estrutura

8> head(soja) # cabeçalho

9> soja # imprime todos os registros




1> # Visualização rápida dos dados

2> head(soja) # cabeçalho

3> potassio agua bloco rengrao pesograo kgrao pgrao ts nvi nv

4> 1 0 37.5 I 14.55 10.70 15.13 1.18 136 22 56

5> 2 30 37.5 I 21.51 13.53 17.12 0.99 159 2 62

6> 3 60 37.5 I 24.62 15.78 19.11 0.82 156 0 66

7> 4 120 37.5 I 21.88 12.80 18.12 0.85 171 2 68

8> 5 180 37.5 I 28.11 14.79 19.11 0.88 190 0 82

9> 6 0 50.0 I 17.16 12.26 12.14 1.05 140 20 63

10>

11> names(soja)

12> [1] "potassio" "agua" "bloco" "rengrao" "pesograo" "kgrao" ←↩"pgrao" "ts"

13> [9] "nvi" "nv"




1> # Acessando informações das variáveis ($)

2>

3> soja$bloco # a variável bloco foi lida como um fator ←↩(variável categórica)

4> [1] I I I I I I I I I I I I I I I II ←↩II II

5> [24] II II II II II II II III III III III III III III III ←↩III III III

6> [47] IV IV IV IV IV IV IV IV IV IV IV IV IV IV V V ←↩V V

7> [70] V V V V V V

8> Levels: I II III IV V

9>

10> soja$rengrao

11> [1] 14.55 21.51 24.62 21.88 28.11 17.16 24.44 28.50 32.94 ←↩28.76 14.13 19.71

12> [16] 15.72 19.72 24.29 25.39 28.45 15.44 28.12 31.49 29.95 ←↩30.06 15.42 23.68

13> [31] 12.77 20.45 24.35 27.15 24.08 16.01 24.57 28.85 26.23 ←↩26.36 16.08 20.99

14> [46] 14.26 23.71 22.76 22.46 22.97 15.54 18.48 25.54 30.29 ←↩30.64 17.26 20.51

15> [61] 10.30 16.28 23.61 29.66 23.34 14.41 17.24 29.08 29.52 ←↩27.98 17.56 20.05

16>

17> soja$potassio # a variável potassio também écategórica, mas ←↩foi lida como numérica

18> [1] 0 30 60 120 180 0 30 60 120 180 0 30 60 120 180 0 ←↩30 60

19> [24] 120 180 0 30 60 120 180 0 30 60 120 180 0 30 60 ←↩120 180 0

20> [47] 30 60 120 180 0 30 60 120 180 0 30 60 120 180 0 30 ←↩60 120

21> [70] 180 0 30 60 120 180




1> # O comando attach() anexa a base de dados ao workspace do R

2> #

3> # Os objetos no banco de dados podem ser acessados simplesmente

4> # digitando seus nomes

5>

6> attach(soja)

7> rengrao

8> [1] 14.55 21.51 24.62 21.88 28.11 17.16 24.44 28.50 32.94 28.76

9> ...

10> [73] 29.90 20.86 35.50

11>

12> # Para desanexar a base de dados

13> detach(soja)

14> rengrao

15> Error: object 'rengrao' not found




1> # Exploração númerica, médias por nível de potássio, água e ←↩potássio:água

2> attach(soja) # anexa a base de dados

3> levels(factor(potassio)) # factor() transforma a variável em ←↩categórica e levels() extrai as categorias

4> [1] "0" "30" "60" "120" "180"

5>

6> tapply(rengrao,potassio,mean) # tapply() aplica um função a ←↩um grupo de valores de um array

7> 0 30 60 120 180

8> 15.10733 21.29733 27.48200 29.51067 30.43200

9>

10> tapply(rengrao,list(agua),mean)

11> 37.5 50 62.5

12> 21.6956 25.1040 27.4980

13>

14> tapply(rengrao,list(potassio,agua),mean) # médias de ←↩rendimento para potassio:agua

15> 37.5 50 62.5

16> 0 13.520 15.712 16.090

17> 30 20.334 22.570 20.988

18> 60 23.926 28.692 29.828

19> 120 25.308 29.786 33.438

20> 180 25.390 28.760 37.146




1> # O comando with avalia uma expressão em uma base de dados

2> # Assim, não precisamos anexar soja

3>

4> # A mesma exploração numérica anterior

5> with(soja, tapply(rengrao, list(potassio), mean))

6> 0 30 60 120 180

7> 15.10733 21.29733 27.48200 29.51067 30.43200

8>

9> with(soja, tapply(rengrao, list(agua), mean))

10> 37.5 50 62.5

11> 21.6956 25.1040 27.4980

12>

13> with(soja, tapply(rengrao, list(potassio, agua), mean))

14> 37.5 50 62.5

15> 0 13.520 15.712 16.090

16> 30 20.334 22.570 20.988

17> 60 23.926 28.692 29.828

18> 120 25.308 29.786 33.438

19> 180 25.390 28.760 37.146Leonardo Goliatt (MAC/UFJF) Introdução ao R v. 13.07 118 / 132



1> # Selecionando subconjuntos dos dados de acordo com os níveis ←↩das categorias

2> subset(soja, potassio==0)

3> subset(soja, bloco=="I")

4> subset(soja, potassio==0 & bloco=="I")

5>

6>

7> # Selecionando subconjunto dos dados por valores das respostas

8> subset(soja, rengrao<15)

9> subset(soja, rengrao<15 & pesograo<11)




1> # Gráficos simples de dispersão (rótulos, cores, simbolos, ←↩tamanhos)

2> plot(rengrao~potassio, data=subset(soja, agua==50))

3> plot(rengrao~potassio, data=subset(soja, agua==50),

4> xlab="Dose de potássio", ylab="Rendimento de grãos",

5> col=2, pch=19, cex=1.2)




1> # Boxplot (subconjuntos e cores)

2> boxplot(rengrao~potassio, data=subset(soja, agua==50))

3> boxplot(rengrao~potassio, data=soja, col="yellow")




1> # Todos níveis de água ao mesmo tempo (título)

2> par(mfrow=c(1,3)) # divide a janela gráfica em uma linha em ←↩três colunas

3> boxplot(rengrao~potassio, data=subset(soja, agua==37.5), ←↩ylim=c(10,45), main="37.5%")

4> boxplot(rengrao~potassio, data=subset(soja, agua==50 ), ←↩ylim=c(10,45), main="50.0%")

5> boxplot(rengrao~potassio, data=subset(soja, agua==62.5), ←↩ylim=c(10,45), main="62.5%")




1> # Gráficos de barras (adição de texto)

2> par(mfrow=c(1,1)) # restaura a janela gráfica

3> pot.m <- with(soja, tapply(rengrao, potassio, mean))

4> bp <- barplot(pot.m) # alterar para ylim=c(0,32)

5> text(bp, pot.m, label=round(pot.m, 3), pos=3) # pos=3

6> title("Médias dos tratamentos")

7> box()




1> # Melhorando o aspecto

2> bp <- barplot(pot.m, ylim=c(0,33), col="seagreen",

3> xlab="Dose de potássio", ylab="Rendimento médio ←↩de grãos")

4> text(bp, pot.m, label=round(pot.m, 3), pos=3, font=3)

5> title("Médias dos tratamentos")

6> box()




1> # Mais análise gráfica: rendimento em função de potassio para ←↩cada grupo de água

2> require(lattice) # biblioteca para gráficos mais elaborados

3> xyplot(rengrao~potassio, groups=agua, data=soja)

4> xyplot(rengrao~potassio, groups=agua, data=soja, ←↩type=c("p","a"))

5> xyplot(rengrao~potassio|agua, data=soja, type=c("p","a"))

6> xyplot(rengrao~potassio|agua, data=soja, type=c("p","smooth"))


Análise de casos Usando o ANOVA

Usando o ANOVA

http://www.personality-project.org/r/r.anova.html


http://www.personality-project.org/r/r.anova.html

Análise de casos Análise Granulométrica do Solo

Análise Granulométrica do Solo

Dados de análise de imagens de agregados (análise morfométrica) deamostras de solo identificadas por dois níveis de profundidade de coleta.As variáveis observadas foram:

área: area (da projeção no plano) do agregado;perimetro: perimetro do poligono (obtido da projeção no plano) do agregado;aspecto e roundness: medidas relativas à forma de um círculo;maioreixo e menoreixo: retas de maior e menor comprimentos comextremos na borda;


Análise de casos Análise Granulométrica do Solo

Análise Granulométrica do Solo

1> # Os dados encontram-se na planilha 'agregados.xls' na pasta ←↩data

2> # Para a leitura dos dados, vamos precisar do pacote gdata

3> library(gdata)

4> agr <- read.xls(xls='./data/agregados.xls')

5>

6> str(agr)

7> 'data.frame': 600 obs. of 7 variables:

8> $ profundidade: int 5 5 5 5 5 5 5 5 5 5 ...

9> $ area : num 0.0038 0.005 0.008 0.0052 0.0055 0.0046 ←↩0.0055 0.0039 ...

10> $ perimetro : num 0.2 0.3 0.4 0.3 0.3 0.2 0.3 0.2 0.3 0.4 ...

11> $ aspecto : num 0.947 0.913 0.806 0.955 0.792 ...

12> $ roundness : num 0.968 0.871 0.795 0.83 0.897 ...

13> $ maioreixo : int 18 22 30 21 23 20 22 23 23 28 ...

14> $ menoreixo : num 17 20 24 20 18 20 19 15 17 27 ...

15>

16> head(agr)

17> profundidade area perimetro aspecto roundness maioreixo ←↩menoreixo

18> 1 5 0.0038 0.2 0.9474 0.9682 18 17

19> 2 5 0.0050 0.3 0.9130 0.8711 22 20

20> 3 5 0.0080 0.4 0.8065 0.7953 30 24

21> 4 5 0.0052 0.3 0.9545 0.8302 21 20

22> 5 5 0.0055 0.3 0.7917 0.8966 23 18

23> 6 5 0.0046 0.2 1.0000 0.9208 20 20


Análise de casos Computação Simbólica no R

Computação Simbólica no R

Em R podemos calcular as derivadas (simbólicas) de expressões simples

1> # Operações simbólicas com expressões simples

2> rm(list=ls()) # limpa o espaço de trabalho

3> # Cria uma expressão simbólica

4> f = expression(cos(x) + x * sin(x))

5> class(f)

6> [1] "expression"

7> # Avalia a expressão, mas x ainda não exite...

8> eval(c)

9> Error in eval(expr, envir, enclos) : object 'x' not found

10> # Repetindo, mas agora com a criação de x

11> x=seq(0,pi,length=20)

12> eval(f)

13> [1] 1.00000000 1.01357652 1.05319340 1.11556315 1.19537338

14> ...

15> [19] -0.49648737 -1.00000000




1> # O grafico de f -- o rótulo de y éuma expressão

2> plot(ef~x,type='b', ylab=f, col='violetred4')




1> # Derivando f simbolicamente usando o comando D()

2> D(f) # faltou o "x"

3> Error in .Internal(D(expr, name)) : 'name' is missing

4> D(f,"x")

5> sin(x) + x * cos(x) - sin(x)

6> # Para derivadas de ordem superior, definimos a função

7> DD <- function(expr,name, order = 1) {

8> if(order < 1) stop("'order' must be >= 1")

9> if(order == 1) D(expr,name)

10> else DD(D(expr, name), name, order - 1)

11> }

12>

13> DD(f,"x",1)

14> sin(x) + x * cos(x) - sin(x)

15> DD(f,"x",2)

16> cos(x) + (cos(x) - x * sin(x)) - cos(x)

17> DD(f,"x",4)

18> -(cos(x) + (cos(x) + (cos(x) - x * sin(x))) + cos(x) - cos(x))




1> # Continuando com as derivadas de ordem superior

2> f4=DD(f,"x",4)

3> f4

4> -(cos(x) + (cos(x) + (cos(x) - x * sin(x))) + cos(x) - cos(x))

5>

6> plot(eval(f4)~x, main=f4, type='b') # observe o título do ←↩gráfico


Education

Introdução ao R