---
title: ''
output:
  pdf_document: default
  html_notebook: default
---

## T3 -- Operaciones basicas en R

### Nociones de programación en R

Os comandos (scripts em linguagem R) devem ser explicitados na linha de comando
(console) ou por meio de um editor de texto (a ser comentado depois). Veja os exemplos
de operações matemáticas (Quadro 2):

Quadro 2: R como super-calculadora.

%Carregando pacote para tabela knitr & kableExtra
```{r}
require(knitr) 
require(kableExtra)
if(!require(data.table)){install.packag
  es("data.table"); require(data.table)}

#Criando conjunto de dados

#OperacoesR <- data.table(Operador = c( "+", "-", "*", "/", "^", "abs", "exp", "log", "sqrt", "rnorm"),
#                        Descricao = c( "Adicao", "Subtracao", "Multiplicacao", "Divisao", "Exponenciacao", "Valor Absoluto", #"log logaritmo (default \'e log natural)", "Raiz quadrada", "sorteia 100.000 valores de uma Normal"),
#                        Exemplos = c( "5+4", "5-4", "5*4", "5/4", "5^4", "abs(-5)", "exp(5)", "log(exp(5)", "sqrt(64)", #"rnorm(100000)"))
Tabela <- data.table(Operador = c("+", "-","*","/", "^", "abs", "exp", "log", "sqrt", "rnorm" ),
                     Descricao = c("Adicao", "Subtracao", "Multiplicacao", "Divisao", "Exponenciacao", "Valor Absoluto", "log logaritmo (default \'e log natural)", "Raiz quadrada", "sorteia 100.000 valores de uma Normal"),
                     Exemplos = c("5+4", "5-4", "5*4", "5/4", "5^4", "abs(-5)", "exp(5)", "log(exp(5)", "sqrt(64)", "rnorm(100000)"))
                    
kable(Tabela, booktabs = T)

```                        

### O R como calculadora
O forma de uso mais básica do R é usá-lo como calculadora. Os operadores matemáticos básicos são:  
+ para soma, - subtração, * multiplicação, / divisão e ^ exponenciação. Digite as seguintes operações na
linha de comandos do R:  

%Carregando pacote para tabela knitr & kableExtra
```{r}
 2+2  
 2*2  
 2/2  
 2-2  
 2^2  
```
Use parênteses para separar partes dos cálculos, por exemplo, para fazer a conta 4+16, dividido por 4,
elevado ao quadrado:
```{r}
 ((4+16)/4)^2  

```
### Funções do R
O R tem diversas funções que podemos usar para fazer os cálculos desejados. O uso básico de uma
função é escrever o nome da função e colocar os argumentos entre parênteses, por exemplo:
função(argumentos). função especifica qual função irá usar e argumentos especifica os
argumentos que serão avaliados pela função. Não se assuste com esses nomes, com um pouco de pratica eles
se tornarão triviais.  
Antes de usar uma função precisamos aprender como usá-la. Para isso vamos aprender como abrir e usar
os arquivos de ajuda do R.


### Objetos do R (O que são?):
O que são os Objetos do R? Existem muitos tipos de objetos no R que só passamos a conhecê-los bem
com o passar do tempo. Por enquanto vamos aprender os tipos básicos de objetos.  
a) vetores: uma seqüência de valores numéricos ou de caracteres (letras, palavras).  
b) matrizes: coleção de vetores em linhas e colunas, todos os vetores dever ser do mesmo tipo (numérico
ou de caracteres).  
c) dataframe: O mesmo que uma matriz, mas aceita vetores de tipos diferentes (numérico e caracteres).  
Geralmente nós guardamos nossos dados em objetos do tipo data frame, pois sempre temos variáveis
numéricas e variáveis categóricas (por exemplo, largura do rio e nome do rio, respectivamente).  
d) listas: conjunto de vetores, dataframes ou de matrizes. Não precisam ter o mesmo comprimento, é a
forma que a maioria das funções retorna os resultados.  
e) funções: as funções criadas para fazer diversos cálculos também são objetos do R.  
No decorrer da apostila você verá exemplos de cada um destes objetos.


### Pastas

A função setwd faz com que você consiga ir a pasta desejada.

```
setwd("Documentos/Cursos/SAR-PolSAR-Course/Code/")
```
A função getwd serve para saber em que pasta você se encontra.
```{r}
getwd()
```
### Como criar objetos
####Objetos vetores com valores numéricos
Vamos criar um conjunto de dados de contém o número de espécies de aves (riqueza) coletadas em 10
locais. As riquezas são 22, 28, 37, 34, 13, 24, 39, 5, 33, 32.  
```{r} 
 aves<-c(22,28,37,34,13,24,39,5,33,32)  
```
O comando <- (sinal de menor e sinal de menos) significa assinalar (assign). Indica que tudo que vem
após este comando será salvo com o nome que vem antes. É o mesmo que dizer "salve os dados a seguir com
o nome de aves".  

A letra c significa concatenar (colocar junto). Entenda como "agrupe os dados entre parênteses dentro do
objeto que será criado" neste caso no objeto aves.  

Para ver os valores (o conteúdo de um objeto), basta digitar o nome do objeto na linha de comandos.
 aves  
 
A função length fornece o número de observações (n) dentro do objeto.  
```{r} 
 length(aves)  
```
Objetos vetores com caracteres (letras, variáveis categóricas).  

Também podemos criar objetos que contêm letras ou palavras ao invés de números. Porem, as letras ou
palavras devem vir entre aspas " ".  
```{r} 
 letras<-c("a","b","c","da","edw")  
7  
 letras  
 
 palavras<-c("Manaus","Boa Vista","Belém","Brasília") 
 
 palavras    
 
```

Crie um objeto "misto", com letras e com números. Funciona? Esses números realmente são números?  

Note a presença de aspas, isso indica que os números foram convertidos em caracteres. Evite criar vetores
"mistos", a menos que tenha certeza do que está fazendo.  

#### Operações com vetores

Podemos fazer diversas operações usando o objeto aves, criado acima.
```{r}
max(aves) #valor máximo contido no objeto aves
min(aves) #valor mínimo
sum(aves) #Soma dos valores de aves
aves^2 #…
aves/10
```
Agora vamos usar o que já sabemos para calcular a média dos dados das aves.
```{r}
n.aves<-length(aves)             # número de observações (n)
media.aves<-sum(aves)/n.aves                        #média
```
Para ver os resultados basta digitar o nome dos objetos que você salvou
```{r}
n.aves # para ver o número de observações (n)
media.aves # para ver a média
```
Você não ficará surpreso em saber que o R já tem uma função pronta para calcular a média.
```{r}
mean(aves)
```

### Acessar valores dentro de um objeto [colchetes]
Caso queira acessar apenas um valor do conjunto de dados use colchetes []. Isto é possível porque o R
salva os objetos como vetores, ou seja, a sequencia na qual você incluiu os dados é preservada. Por exemplo,
vamos acessar o quinto valor do objeto aves.
```{r}
aves[5] # Qual o quinto valor de aves?
palavras[3] # Qual a terceira palavra?
```
Para acessar mais de um valor use c para concatenar dentro dos colchetes [c(1,3,...)]:
```{r}
aves[c(5,8,10)] # acessa o quinto, oitavo e décimo valores
```
Para excluir um valor, ex: o primeiro, use:
```{r}
aves[-1] # note que o valor 22, o primeiro do objeto aves, foi excluído

```
Caso tenha digitado um valor errado e queira corrigir o valor, especifique a posição do valor e o novo valor.
Por exemplo, o primeiro valor de aves é 22, caso estivesse errado, ex: deveria ser 100, basta alterarmos o valor
da seguinte maneira.
```{r}
aves[1]<-100 # O primeiro valor de aves deve ser 100
aves
aves[1]<-22 # Vamos voltar ao valor antigo
```

###Gerar seqüências (usando : ou usando seq)

: (dois pontos)
Dois pontos " : " é usado para gerar seqüências de um em um, por exemplo a seqüência de 1 a 10: 
```{r}
1:10 # O comando : é usado para especificar seqüências.
5:16 # Aqui a seqüência vai de 5 a 16
```

seq
A função seq é usada para gerar seqüências especificando os intervalos.
Vamos criar uma seqüência de 1 a 10 pegando valores de 2 em 2.
```{r}
seq(1,10,2) #seq é a função para gerar seqüências, o default é em intervalos de 1.
```
A função seq funciona assim:

seq(from = 1, to = 10, by = 2 ), seqüência(de um, a dez, em intervalos de 2)
```{r}
seq(1,100,5) #seqüência de 1 a 100 em intervalos de 5
seq(0.01,1,0.02)
```
### Gerar repetições (rep)
rep
Vamos usar a função rep para repetir algo n vezes.
```{r}
rep(5,10) # repete o valor 5 dez vezes
```
A função rep funciona assim: 

rep(x, times=y) # rep(repita x, y vezes) # onde x é o valor ou conjunto de valores que deve ser
repetido, e times é o número de vezes)
```{r}
rep(2,5)
rep("a",5) # repete a letra "a" 5 vezes
rep(1:4,2) # repete a seqüência de 1 a 4 duas vezes
rep(1:4,each=2) # note a diferença ao usar o comando each=2
rep(c("A","B"),5) # repete A e B cinco vezes.
rep(c("A","B"),each=5) # repete A e B cinco vezes.
rep(c("Três","Dois","Sete","Quatro"),c(3,2,7,4)) # Veja que neste
```
caso a primeira parte do comando indica as palavras que devem ser repetidas e a segunda parte indica quantas
vezes cada palavra deve ser repetida

### Gerar dados aleatórios
runif (Gerar dados aleatórios com distribuição uniforme)

runif(n, min=0, max=1) # gera uma distribuição uniforme com n valores,

começando em min e terminando em max.
```{r}
runif(200,80,100) # gera 200 valores que vão de um mínimo de 80 até um máximo de 100
temp<-runif(200,80,100)
hist(temp) # Faz um histograma de freqüências dos valores
```
rnorm (Gerar dados aleatórios com distribuição normal)

rnorm(n, mean=0, sd=1) # gera n valores com distribuição uniforme, com média 0 e desvio padrão 1.
```{r}
rnorm(200,0,1) # 200 valores com média 0 e desvio padrão 1
temp2<-rnorm(200,8,10) # 200 valores com média 8 e desvio padrão 10
hist(temp2) # Faz um histograma de frequências dos valores
```
Veja o help da função ?Distributions para conhecer outras formar de gerar dados aleatórios com
diferentes distribuições.

### Fazer amostras aleatórias
A função sample
A função sample é utilizada para realizar amostras aleatórias e funciona assim:
sample(x, size=1, replace = FALSE)# onde x é o conjunto de dados do qual as
amostras serão retiradas, size é o número de amostras e replace é onde você indica se a amostra deve ser feita com reposição (TRUE) ou sem reposição (FALSE).
```{r}
sample(1:10,5) # tira 5 amostras com valores entre 1 e 10
```
Como não especificamos o argumento replace o padrão é considerar que a amostra é sem reposição
(= FALSE).

sample(1:10,15) # erro, amostra maior que o conjunto de valores, temos 10 valores (1 a 10)

portanto não é possível retirar 15 valores sem repetir nenhum!
```{r}

sample(1:10,15,replace=TRUE) # agora sim!
```
Com a função sample nós podemos criar varios processos de amostragem aleatória. Por exemplo,
vamos criar uma moeda e "jogá-la" para ver quantas caras e quantas coroas saem em 10 jogadas.
```{r}
moeda<-c("CARA","COROA") # primeiro criamos a moeda
```
sample(moeda,10)

ops! Esqueci de colocar replace=TRUE
```{r}
sample(moeda,10,replace=TRUE) # agora sim
```

