Módulo 1 – Conhecendo o Ambiente R

Linguagem de Programação

Linguagem é uma estrutura sistemática que tem por objetivo a transmissão de ideias e sentimentos (comunicação), ela pode ocorrer através da fala (a língua é um tipo de linguagem que podemos classificar como verbal), escrita (sinais ou símbolos) ou outros signos convencionais. Dessa maneira, uma linguagem de programação é um conjunto de símbolos, sintáticas, regras semânticas destinadas ao controle de uma máquina, por isso ela é uma forma de comunicação entre o ser humano e o computador.

A comunicação entre Homem e Máquina é mediado pelo uso da linguagem de programação, esta por sua vez pode ser classificada como linguagem de alto nível e linguagem de baixo nível, esta classificação está baseada no nível de abstração de cada linguagem de programação.

Linguagem de Alto Nível

São linguagens cuja sintaxe são voltadas para o entendimento humano, logo, tais linguagens são mais intuitivas/amigáveis. Para que exista um canal de comunicação entre o emissor (homem) e o receptor (máquina) é necessário que o código seja abstraído e sintetizado de modo que ambos entendam, já que o computador só compreende a linguagem binária. Tomamos como exemplo o Código “PRINT”, o emissor que no caso somos nós, estabelecemos esse comando que será abstraído/ convertido em zeros e uns através dos compiladores para a máquina e ela por sua vez retornará funções que mostrem o conteúdo capturado na tela do computador. São exemplos desse tipo de linguagem o JavaScript, Python, C#, PHP etc.

É intuitivo pensar que os códigos escritos precisam ser compilados ou interpretados para que a máquina entenda o que queremos transmitir. Quando um código é compilado, é gerado outro arquivo que contém todo o código traduzido para algo mais próximo da linguagem da máquina (no caso é um programa em Assembly). Já quando o código é interpretado, cada linha de comando é “traduzida” no momento da execução e é aqui que o Programa R se encaixa. É justamente isso que eleva o tempo de processamento.

Linguagem de Baixo Nível

São linguagens voltadas para o entendimento da máquina, logo, tais linguagens possuem uma sintaxe mais complexa e não contam com comandos muito intuitivos. Como mencionado anteriormente, a linguagem da máquina é constituída por sequências de 0 e 1, então a linguagem de baixo nível tem instruções mais diretas para o processador do computador, logo, tais instruções são mais próximas da linguagem da máquina. Um exemplo de tal linguagem é o Assembly.

A linguagem de baixo nível é “traduzida” pelo que chamamos de montador (assembler), que é o responsável por converter o programa Assembly em um conjunto de instruções na linguagem de máquina. Com isso, podemos perceber que o Assembly também atua como uma espécie de interface entre a linguagem de alto nível e a linguagem da máquina.

Linguagem de Alto Nível vs Baixo Nível

Um simples exemplo é se o emissor deseja que a máquina mostre na tela o código Wesley.

Em Python (Alto Nível) o Emissor escreveria o seguinte comando: print(“Wesley”)

Em Assembly tal comando seria transcrito da seguinte forma:

lea si, string
call printf
hlt
string db “Wesley”, 0
printf PROC
mov AL, SI
cmp AL, 0
je pfend
mov AH, 0Eh
int 10h
inc SI
jmp printf
pfend:
ret
printf ENDP

Vantagens e Desvantagens de cada uma

Alto Nível: As principais vantagens são o fácil aprendizado e o baixo custo operacional. As desvantagens reside na exigência de um tempo de processamento maior para executar determinados comandos, por isso que o desempenho de um programa pode ser prejudicado, outra desvantagem é que essa linguagem ocupam mais memórias se comparadas as de baixo nível.

Baixo Nível: A principal vantagem está no tempo de processamento muito mais rápido do que numa linguagem de alto nível. A desvantagem está na dificuldade de abstração de conceitos nessa linguagem, outra desvantagem é que esses códigos são dedicados a tipos de processadores, logo sua compatibilidade é extremamente limitada.

Resumindo: Uma linguagem busca facilitar o entendimento humano, enquanto outra se aproxima mais da linguagem da máquina

O que é o programa R?

Segundo o site oficial do programa o R é uma linguagem e ambiente para computação com foco em estatística e gráficos, é importante perceber que esse ambiente de programação nada mais é que um projeto GNU semelhante a linguagem e ambiente S desenvolvido pela Bell Laboratories por John Chambers e colegas. Por ser basicamente um projeto GNU, o R é um software livre que pode ser estendido através da utilização de pacotes por meio da família CRAN de sites da internet. O termo ambiente pretende caracterizar o R como um sistema totalmente planejado e coerente e ai está a principal diferença entre esse ambiente com os sofwares de análise de dados, o R permite ao pesquisador certa liberdade na hora da análise de dados, já que tal ambiente de programação acompanha o progresso científico, ou seja: novas abordagens metodológicas são desenvolvidas e disponibilizadas nessa plataforma através da criação de pacotes estatísticos, que são disponibilizados para a comunidade científicas através da página oficial CRAN ou pelo github.

O programa foi desenvolvido por George Ross Ihaka e Robert Clifford Gentleman em 1991, nesta ocasião, os professores (Ihaka e Gentleman) que trabalhavam na Universidade de Auckland (Nova Zelândia) desenvolveram uma alternativa à linguagem S, na qual foi oficialmente divulgado em 1995. Em 1997, um grupo central responsável pelas atualizações e estabilizações do programa foi criado e chamado de R Development Core Team, no mesmo ano surgiu o CRAN (Comprehensive R Archive Network) que consiste num conjunto de sites (espelhos) que transportam material idêntico com as contribuições do R de uma forma geral.

A linguagem R é uma linguagem interpretada, isto é, o código fonte nessa linguagem é executado por um programa de computador (interpretador) na qual interpreta linha por linha (e aqui está a diferença entre uma linguagem compilada e uma interpretada, na linguagem compilada o compilador converte todo o código de uma vez para a linguagem binária, por causa disso o processo compilado é muito mais rápido que o traduzido, na qual o processo é repetitivo, pois o interpretador processa o código linha por linha) que em seguida é processado pelo sistema operacional ou processador.

O que é o RSTudio?

Basicamente o RStudio (Figura 1) é uma interface gráfica criado por Joseph J. Allaire. Essa interface deixou o R mais popular, já que o RStudio facilita a utilização de vários recursos por meio de botões e uma interface parecida com os programas usuais utilizados por vários sistemas operacionais.

Digamos que o RStudio é mais amigável com o estudante que está aprendendo essa nova linguagem. Uma das vantagens dessa interface é a disposição de quadrantes que organizam as atividades dentro dessa plataforma. Podemos configurar a aparência e a ordem dos quadrantes no RStudio em: Tools > Global Options > Appearance e em Pane Layout.

Instalando o R e o RStudio:

Como mencionamos anteriormente, uma das vantagens do “programa R” é sua compatibilidade com vários sistemas Operacionais, portanto, vamos mostrar como podemos instalar esse sistema tanto no Windows como no Linux Mint (Uma das distros mais utilizadas do Linux e foi baseada no Ubuntu, portanto essas duas distros possuem ampla compatibilidade entre si).

Instalando o R e RStudio no Windows

Podemos instalar o R nesse link e o RStudio nesse respectivamente

Instalando o R e o RStudio no Linux Mint

Essa etapa é um pouco mais complicada, no primeiro passo iremos acessar o site oficial do R em seguida escolhemos a opção “Download R for Linux”, depois selecionamos a opção “ubuntu/” e copiamos a chave do repositório para isso clicamos na opção “full README”, logo iremos copiar o apt-key, no nosso caso copiaremos a chave “E298A3A825C0D65DFD57CBB651716619E084DAB9”, com a chave copiada é só acessar no meno iniciar o aplicativo “Fontes de Aplicativos”, em seguida basta clicar na Chaves de Autenticação e apertar em baixar, dai é só colar a chave copiada e apertar em OK, após isso aceite a atualização do repositório. Precisamos adicionar o repositório Para isso iremos acessar novamente a página do R e vamos copiar o comando
“deb https://cloud.r-project.org/bin/linux/ubuntu focal-cran40/”, em seguida Adicionaremos esse repositório no aplicativo Fontes de Aplicativos e em Adicionar apertaremos em OK, logo adicionaremos o seguinte comando: “sudo apt-get install r-base r-base-dev” no terminal (Ctrl + Alt + T) e confirmamos a instalação digitando S e apertando Enter.

Para abrir o R no terminal é só digitar o R maiúsculo e apertar Enter. ]

Para instalar o RStudio é só acessar o link do RStudio ir na opção downloads e escolher a versão Ubuntu18/Debian 10, após baixado é só instalar normalmente como faria no Windows apertando o botão Instalar Pacotes.

Entendendo o Funcionamento do R:

Segundo Chambers em seu livro “Extending R” o programa R tem uma estrutura interna uniforme para representar todos os objetos, resumidamente essa estrutura é composta por chamadas de funções que possuem objetos como argumentos e como valor.

Podemos sumarizar esse conceito em três princípios, sendo eles:

  • Princípio do Objeto: Na qual afirma que tudo que existe no R é um OBJETO

  • Princípio da Função: Tudo que acontece no R é uma chamada de FUNÇÃO

  • Princípio da Interface: Interfaces para outros programas são parte do R.

Podemos resumir o funcionamento do programa na seguinte situação: Toda ação que acontece nesse programa é realizado através de uma chama de função o resultado dessa chama de função é armazenada na forma de um objeto que por fim é associado a um nome.

Iniciando o R/RStudio:

Nas linhas de comando do R, mais especificamente no console do RStudio haverá um sinal de >, que indica o prompt, na qual representa que o programa está esperando um comando para realizar uma tarefa. É após esse sinal que iremos escrever nossas linhas de comando. Podemos alterar esse símbolo, escrevendo o seguinte comando

options(prompt = "W>")
#Toda vez que o console iniciar, começará por 'W>'

É importante estar atento quanto aos nomes dos nossos objetos, já que o programa diferencia letras maiúsculas e minúsculas, logo, não podemos chamar a função library(vegan) escrevendo Library(Vegan).

Regras sintáticas do Programa

Ao nomear um Objeto, devemos optar pela utilização de letras ou dígitos (preferencialmente); Não podemos iniciar o nome com underline ( _ ); Também não podemos utilizar qualquer uma das palavras reservadas pela linguagem como os operadores lógicos TRUE, FALSE, os operadores de controle IF, FOR, ELSE, WHILE. Se estiver em dúvida utilize a função ?Reserved().

Devemos utilizar o ponto para representar os números decimais, já que os símbolos , . \ / ; representam funções específicas dentro da linguagem. Como bem sabemos que o R é uma linguagem interpretada, devemos apertar o enter em cada linha de comando digitada para que o console execute tais comandos, ou podemos simplesmente adicionar ; em cada sentença para que o R rode automaticamente todo o código escrito e separado por ponto e vírgula ( ; ), caso o comando digitado esteja incompleto, o programa substituirá o símbolo ( > ) do prompt por um sinal aditivo ( + ). Aqui está uma vantagem do RStudio, se pretendermos escrever o comando para abrir um determinado objeto do tipo função, na qual apresentam argumentos necessários para utilizar de forma correta tais funções, pois esses argumentos apresentam requisitos e elementos necessário para a plena execução dessas funções. Para exemplificar essa vantagem vou utilizar a uma função para abrir pacotes disponíveis na biblioteca do nosso disco rígido, por exemplo, basta escrever librar (de forma incompleta mesmo e o programa vai sugerir imediatamente o complemento dessa função, que no caso é library(), além disso o programa informará automaticamente uma descrição bem resumida da função escrita e dos argumentos que compõe tal função, e se apertarmos F1 automaticamente o programa abrirá a página de ajuda da função/pacote no quadrante help).

Para encerrar o R/RStudio é só fechar o programa ou escrever q()

Esta função geralmente é seguida por uma pergunta save workspace image? y/n/c. Se a resposta dada for y (sim), o programa salvará os conjuntos de dados armazenados na memória, bem como o histórico de comandos. É sempre interessante escrever um registro das análises feitas gravando os comandos em um arquivo de texto chamado arquivo de script, no RStudio basta apertar Ctrl + Enter para que a linha de comando escrita no Script rode no Console.

Comandos de Ajuda no RStudio

Podemos abrir facilmente a página de ajuda de um determinado pacote ou função, por exemplo, em ambos os programas (R/RStudio) podemos escrever o comando help(lm) para que a página de help abra em um dos quadrantes da plataforma, do mesmo modo podemos escrever a expressão ?lm, para acessar essa mesma página de ajuda.

Diretório de Trabalho

Basicamente um dos principais erros que acontece em uma rotina de programação R é acessar algum arquivo que não está no diretório de trabalho ou até mesmo salvar em um diretório sem ao menos prestar atenção onde o programa está salvando/acessando os arquivos. Esse lugar é conhecido como diretório de trabalho e o R estabelece uma conexão com esse lugar toda vez que o programa é iniciado. Para verificar seu diretório de trabalho, utilize o comando:

getwd()
## [1] "/home/weneves/Documentos/Trabalhos R"

Para alterar o diretório de trabalho existe a função setwd()
No RStudio basta acessarmos Tools/Global Options/General/Default Working Directory (when not in a project):

setwd("/home/weneves/Documentos/Trabalhos R")

OBS: O programa só aceita o formato padrão da Barra Oblíqua / e não a Barra Invertida \ Se você optar em copiar o endereço de um arquivo que não está no diretório de trabalho, basta ir em Propriedades do arquivo e copiar o endereço. O endereço por padrão está escrito com as barras invertidas, então ou você duplica essas barras invertidas ( \\ ) ou inverte para a Barra Normal ( / ). Para salvar o workspace utilizaremos o comando ’save.image() ou Ctrl + Alt + S (RStudio)

O R gravará o workspace no arquivo .RDATA. O .RData salvará todos os objetos criados que estão atualmente disponíveis e o .Rhistory salvará todas as linhas de comandos inseridas no console. Ao iniciar o R no mesmo diretório onde esses arquivos foram salvos, é carregado toda a sua área de trabalho anteriormente, bem como o histórico das linhas de comando utilizadas.

Comandos Elementares:

Toda ação que pode ser executada no R pode ser dividida em duas (Expressão e Atribuição), se quiséssemos utilizar o R como calculadora, podemos simplesmente executar o comando:

1000 + 1014
## [1] 2014

Isto acontece por causa do segundo princípio Tudo que acontece no R é uma chama de função o símbolo de adição no R é simplesmente uma função interna primitiva que foi implementada em outra linguagem. É importante lembrar que toda expressão utilizada no programa fica temporalmente armazenada na memória ativa do computador e uma vez que o resultado é impresso no console, o valor é perdido. Podemos contornar esse problema utilizando o segundo tipo de comando elementar que é a Atribuição (na qual podemos utilizar a junção dos símbolos <- ou =, sendo esse segundo não recomendado, assunto que falaremos posteriormente) não importa a ordem de associação, por exemplo:

x <- 25; x
## [1] 25
25 -> x; x
## [1] 25

Também podemos utilizar o comando assign():

assign("name", "wesley"); name
## [1] "wesley"

Quando utilizamos o comando de atribuição no console, o R armazena o nome associado ao objeto (é importante lembrar que ao utilizarmos essa função, estamos apenas associando um nome a um objeto, que no caso pode ser uma função, um valor, um caractere etc e não estamos de fato, utilizando essa função para criar um objeto) na sua área de trabalho que é comumente chamada de Ambiente Global (o propósito de um ambiente no R é associar um conjunto de nomes a um conjunto de valores)

Podemos criar alguns nomes e associá-los a alguns valores, por exemplo:

D <- c("25-07-2014"); x <- 3.14; e <- 2.71; D; x; e
## [1] "25-07-2014"
## [1] 3.14
## [1] 2.71

Podemos verificar todos os nomes armazenadas no ambiente global através da função ls()

ls()
## [1] "D"    "e"    "name" "x"

Objetos

Lembrando do primeiro princípio do R Tudo que existe no R é um Objeto, e o que seria esse tal de objeto?

A ciência da computação define um objeto como um local da memória destinado a um determinado valor, dessa forma, o objeto pode ser uma variável, uma função ou simplesmente uma estrutura de dados. Mas na Programação Orientada a Objetos, a palavra se refere a um Molde/Classe que passa a existir a partir de uma instância da classe, ou seja, a classe define o comportamento do objeto (utilizando para tais, seus atributos que nada mais são que propriedades e suas ações que são seus métodos). Dessa maneira, podemos resumir a definição de objeto como uma entidade no ambiente R que possuí características internas e tas características são extremamente necessárias para que o programa possa interpretar sua estrutura e seu conteúdo, como vimos acima, tais características são chamadas de atributos.

Podemos retornar ao enunciado que comumente proferimos ao utilizar o R “Criei um objeto x que recebe um valor y”. Segundo a lógica de funcionamento do R, tal afirmação é bastante imprecisa e o correto seria afirmar que o objeto y recebe um nome ou mais corretamente “está se ligando” ao nome x, ou seja, o objeto não tem um nome, mas o nome possui um objeto. Para visualizar qual objeto associado a um nome, basta digitarmos no console o nome associado a tal objeto e apertar a tecla ENTER.

Como afirma Paradis em seu livro “R for Beginners” os objetos são caracterizados pelos seus nomes e pelo seu conteúdo, sendo mais específico seu atributo que normalmente irá especificar o tipo de dados representados por um objeto. podemos utilizar o mesmo exemplo que o autor citado acima trás em seu livro: “considere uma variável que assume o valor 1, 2 ou 3: tal variável pode ser uma variável inteira (por exemplo, o número de ovos em um ninho), ou a codificação de uma variável categórica (por exemplo, sexo em algumas populações de crustáceos: machos, fêmeas ou hermafroditas). É claro que a análise estatística desta variável não será a mesma em ambos os casos: com R, os atributos do objeto fornecem as informações necessárias”. Logo, a ação de um objeto depende dos seus respectivos atributos.

No R todos os objetos possuem uma classe e dois atributos intrínsecos. A forma de verificar a classe de um objeto é através da função class(), mas essa função pode apresentar resultados equívocos e por isso podemos utilizar a função sloop::s3_class() do pacote sloop.

OBS: também existe um atributo chamado classe (class) e os objetos que possuem tal atriuto são apenas os desenvolvidos na programação orientada a objetos (que é uma programação desenvolvida em um dos principais paradigmas da programação que é baseada no conceito de objetos).

q <- 10; a <- factor(q); class(q); class(a)
## [1] "numeric"
## [1] "factor"

Apesar do objeto a possuir o mesmo “conteúdo” que q, pelo simples fato de atribuímos a classe factor ao objeto a, o valor contido em tal nome deixa de se comportar como numérico e passa a ser considerado como fator, portanto, realizar operações algébricas com o objeto a é impossível.

A função attibutes() verifica se determinado objeto possuí o atributo class. As classes dos objetos podem ser: numeric, logical, character, list, matrix, arraym factor e data.frame. Podemos remover a classe de um objeto com a função unclass(). Vamos observar como um data frame se comporta sem a sua classe:

neo <- data.frame(a = 1:16, b = LETTERS[1:16]); class(neo)
## [1] "data.frame"

Agora vamos remover a classe do objeto neo:

b <- unclass(neo); b; class(b)
## $a
##  [1]  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16
## 
## $b
##  [1] "A" "B" "C" "D" "E" "F" "G" "H" "I" "J" "K" "L" "M" "N" "O" "P"
## 
## attr(,"row.names")
##  [1]  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16
## [1] "list"

Observamos que sem o atributo de classe data.frame o objeto tem a classe list, ou seja, mesmo que os dados possuam uma estrutura de lista ele se comporta como data.frame se possuir o atributo data.frame.

Atributos Intrínsecos

Todos os objetos no R possuem dois atributos intrínsecos sendo eles o modo e o comprimento.

  • O modo é o tipo mais básico dos elementos do objeto e existem cerca de quatro modos principais sendo eles numérico, caractere, complexo e lógico (existem outros modos, mas eles não representam dados, como a função e expressão).

  • O comprimento é o número de elementos do objeto. Podemos facilmente consultar essas informações utilizando as funçõesmode()e lenght(), respectivamente:

Alunos_R <- 8; mode(Alunos_R)
## [1] "numeric"
Alunos_R1 <- 8L; mode(Alunos_R1)
## [1] "numeric"

É importante perceber aqui que embora a quantidade de alunos é igual nesses dois exemplos (Alunos_R == Alunos_R1), a função mode() é baseada em uma das linguagem que o R foi baseado (linguagem S), logo ela não faz distinção entre números inteiros e numéricos, essa implementação foi disponibilizada na linguagem C (já que boa parte da rotina do R está desenvolvida nessa linguagem, um exemplo é o pacote base), podemos verificar essa informação através do comando typeof()

typeof(Alunos_R); typeof(Alunos_R1)
## [1] "double"
## [1] "integer"

A diferença entre ambas essas duas formas está simplesmente na forma que o R armazena essas informações na memória do computador, podemos realizar alguns testes no R:

is.numeric( Alunos_R)
## [1] TRUE
is.numeric( Alunos_R1)
## [1] TRUE
is.integer(Alunos_R)
## [1] FALSE
is.integer(Alunos_R1)
## [1] TRUE

Colocar o ‘L’ maiúsculo após um número inteiro força o R a armazenar o valor do objeto como um número inteiro, logo, inteiro seria uma subconjunto de numérico.

O termo double retornado pela funçãotypeof() significa dupla precisão na linguagem de programação, que acaba tenho uma exigência de mais memória do que o objeto de modo integer. Esses termos são utilizados na linguagem C. Já a linguagem S não os diferencia, utilizando tudo como numeric.

Nomes_alunos_R <- c("Beethoven","Chopin","Lizt","Mozart","Bach","Tchaikovsky","Debussy","Schubert"); mode(Nomes_alunos_R)
## [1] "character"
Alunos_Matriculados <- Alunos_R == 8; mode(Alunos_Matriculados)
## [1] "logical"
x <- 3i; mode(x) #Complex
## [1] "complex"

O comprimento de um objeto é informado pela função length()

length(Nomes_alunos_R)
## [1] 8

Tipos de Objetos:

Quando nos referimos a tipos de objeto, estamos pensando na forma que os dados estão organizados, um dos tipos mais simples de objetos são os vetores atômicos que armazenam apenas um conjunto de elementos do mesmo modo (numérico, caractere, complexo e lógico) pela natureza desses objetos (armazenam elementos de apenas um modo) os dados se comportariam do mesmo modo mesmo constituídos de elementos diferentes, por exemplo:

H <- c("shannon", 2.75, 1.68, 2.18, 0.78); H
## [1] "shannon" "2.75"    "1.68"    "2.18"    "0.78"

Observamos que todos os elementos dispostos no meu objeto ganharam aspas, se verificarmos o modo desse objeto constataremos que os dados são characteres. Esse fato chamamos de coerção entre vetores. Os vetores lógicos (TRUE e FALSE) serão convertidos em 1 e 0 respectivamente. A função as. <modo força a coerção dos objetos e para saber se um objeto possui determinado modo, utilizamos a função is. <modo.

Os objetos podem ser resumidos em vetores atômicos ou listas, sendo subdivididos em:

  • Vetores Atômicos (Lógicos, Numéricos e Caracteres; Matrizes Unidimensionais Matrix e Multidimensionais Arrays)

  • Vetores em Listas (Listas e Quadro de Dados Data.frames). A diferença entre os Vetores Atômicos e os Vetores em Listas é que o segundo suporta a presença de vários modos no mesmo objeto, enquanto os vetores atômicos não.

Vetor Numérico:

dados <- c(1,2,3,4,5,6,7,8,9); dados
## [1] 1 2 3 4 5 6 7 8 9
X <- seq(1,10,2); X #Cria uma sequência de números de 1 até 10 2 em 2.
## [1] 1 3 5 7 9
Y <- rep(2:5, 2); Y #Repete a sequência de 2 até 5 duas vezes.
## [1] 2 3 4 5 2 3 4 5

Um conjunto de dados aleatórios pode ser obtido pela funçãorunif(número de dado, min=,max)

teste <- runif(10, min = 30, max = 65); teste
##  [1] 58.97488 40.35845 49.20043 45.93648 63.66903 61.19873 42.76966 39.20701
##  [9] 50.15948 48.54853
#Rnorm()' gera números aleatórios com distribuição normal:
exemplo_distNorm <- rnorm(100, mean = 50, sd = 5); exemplo_distNorm
##   [1] 50.44371 44.58113 47.71237 46.93820 47.28415 53.81965 57.88931 52.83322
##   [9] 50.89715 46.39036 50.68985 48.78306 44.54459 50.47097 55.85282 52.66196
##  [17] 52.95022 51.58645 55.32758 48.49437 54.74176 47.32253 48.92151 49.10214
##  [25] 49.61310 52.34780 54.30959 43.46189 45.79741 48.16988 53.11765 50.50226
##  [33] 51.84235 53.85723 47.95421 54.99717 56.97100 48.61145 50.36949 45.94560
##  [41] 47.31130 47.59637 46.03561 51.97967 52.44848 49.02470 53.44524 45.15296
##  [49] 45.05989 47.42120 55.91810 45.42374 48.70301 53.48134 37.80682 43.80612
##  [57] 53.41456 33.40239 49.87789 51.01625 55.87029 48.96392 41.28892 48.75066
##  [65] 46.84047 46.45459 45.16438 42.29131 44.18256 42.16442 56.40127 40.49731
##  [73] 50.26053 62.86889 43.97625 47.97813 55.88075 53.04730 48.95505 46.36799
##  [81] 49.70672 53.29807 51.76118 44.30815 47.84301 54.42961 41.02442 45.95532
##  [89] 57.17767 50.31737 58.63798 53.18540 53.28980 48.51326 43.65757 48.83139
##  [97] 56.33666 46.16765 47.87546 43.74193

Como selecionar amostras aleatórias de um conjunto de dados?

sample(x, size, replace)

x: vetor com o conjunto de amostras, size: número de amostras a serem selecionadas, replace: lógico, TRUE= com reposição, FALSE= sem reposição.

sample(1:30, 5, replace=FALSE)
## [1] 17 10 22 25 14

Vetor de Caracter

Vetores com nomes ao invés de números.

OBS: No R sequências de caracteres textuais são sempre delimitados por aspas.

dados_chopin <- c(Nome = "Frédéric François Chopin", Nascimento = "22/02/1810", Profissao = "Compositor e Pianista"); dados_chopin
##                       Nome                 Nascimento 
## "Frédéric François Chopin"               "22/02/1810" 
##                  Profissao 
##    "Compositor e Pianista"

Vetor Lógico

Quantidades lógicas no R, sendo eles TRUE, FALSE ou NA

is.factor('dados_chopin')
## [1] FALSE

Fator

Fator é um vetor usado para criar variável categórica (medida em uma escala nominal) que são bastantes comuns em análises estatísticas.

alturas <- factor(c("baixo","médio" ,"alto")); alturas #notem que utilizamos um acento em médio, isto é possível porque esta palavra aqui é tratada como um caracter (por isso as aspas)
## [1] baixo médio alto 
## Levels: alto baixo médio
is.factor(alturas) # testa a conversão
## [1] TRUE

Matriz

Nada mais é que um conjunto de 2 dimensões de vetores (Linhas e colunas)

Escreva matr no RStudio para verificar o corpo da Matrix.

Corpo da Matrix: (data, nrow(n°linhas), ncol(n°colunas), byrow(F or T Organiza a distr. dos n°), dimnames(nomes))

xyz <- matrix(1:100, ncol = 10, byrow = FALSE); xyz # Matriz com byrow = T -> Distribui os números por linhas # Matriz com byrow = F -> Distribui por colunas
##       [,1] [,2] [,3] [,4] [,5] [,6] [,7] [,8] [,9] [,10]
##  [1,]    1   11   21   31   41   51   61   71   81    91
##  [2,]    2   12   22   32   42   52   62   72   82    92
##  [3,]    3   13   23   33   43   53   63   73   83    93
##  [4,]    4   14   24   34   44   54   64   74   84    94
##  [5,]    5   15   25   35   45   55   65   75   85    95
##  [6,]    6   16   26   36   46   56   66   76   86    96
##  [7,]    7   17   27   37   47   57   67   77   87    97
##  [8,]    8   18   28   38   48   58   68   78   88    98
##  [9,]    9   19   29   39   49   59   69   79   89    99
## [10,]   10   20   30   40   50   60   70   80   90   100
colnames(xyz)<-c("grupo1","grupo2","grupo3","grupo4","grupo5","grupo6","grupo7","grupo8","grupo9","grupo10"); rownames(xyz) <- rownames(xyz, do.NULL = FALSE, prefix = "Obs."); linhas <- letters[1:10]; rownames(xyz) <- linhas; xyz
##   grupo1 grupo2 grupo3 grupo4 grupo5 grupo6 grupo7 grupo8 grupo9 grupo10
## a      1     11     21     31     41     51     61     71     81      91
## b      2     12     22     32     42     52     62     72     82      92
## c      3     13     23     33     43     53     63     73     83      93
## d      4     14     24     34     44     54     64     74     84      94
## e      5     15     25     35     45     55     65     75     85      95
## f      6     16     26     36     46     56     66     76     86      96
## g      7     17     27     37     47     57     67     77     87      97
## h      8     18     28     38     48     58     68     78     88      98
## i      9     19     29     39     49     59     69     79     89      99
## j     10     20     30     40     50     60     70     80     90     100
t(xyz)#transpõe a matriz
##          a  b  c  d  e  f  g  h  i   j
## grupo1   1  2  3  4  5  6  7  8  9  10
## grupo2  11 12 13 14 15 16 17 18 19  20
## grupo3  21 22 23 24 25 26 27 28 29  30
## grupo4  31 32 33 34 35 36 37 38 39  40
## grupo5  41 42 43 44 45 46 47 48 49  50
## grupo6  51 52 53 54 55 56 57 58 59  60
## grupo7  61 62 63 64 65 66 67 68 69  70
## grupo8  71 72 73 74 75 76 77 78 79  80
## grupo9  81 82 83 84 85 86 87 88 89  90
## grupo10 91 92 93 94 95 96 97 98 99 100
class(xyz)
## [1] "matrix" "array"
xyz[,1] #para acessar a primeira coluna de uma matriz. [linha, coluna]
##  a  b  c  d  e  f  g  h  i  j 
##  1  2  3  4  5  6  7  8  9 10
fix(xyz) #edita uma matriz ou data frame IMPORTANTE!!
str(xyz)#avalia a estrutura do objeto
##  num [1:10, 1:10] 1 2 3 4 5 6 7 8 9 10 ...
##  - attr(*, "dimnames")=List of 2
##   ..$ : chr [1:10] "a" "b" "c" "d" ...
##   ..$ : chr [1:10] "grupo1" "grupo2" "grupo3" "grupo4" ...
summary(xyz)
##      grupo1          grupo2          grupo3          grupo4     
##  Min.   : 1.00   Min.   :11.00   Min.   :21.00   Min.   :31.00  
##  1st Qu.: 3.25   1st Qu.:13.25   1st Qu.:23.25   1st Qu.:33.25  
##  Median : 5.50   Median :15.50   Median :25.50   Median :35.50  
##  Mean   : 5.50   Mean   :15.50   Mean   :25.50   Mean   :35.50  
##  3rd Qu.: 7.75   3rd Qu.:17.75   3rd Qu.:27.75   3rd Qu.:37.75  
##  Max.   :10.00   Max.   :20.00   Max.   :30.00   Max.   :40.00  
##      grupo5          grupo6          grupo7          grupo8     
##  Min.   :41.00   Min.   :51.00   Min.   :61.00   Min.   :71.00  
##  1st Qu.:43.25   1st Qu.:53.25   1st Qu.:63.25   1st Qu.:73.25  
##  Median :45.50   Median :55.50   Median :65.50   Median :75.50  
##  Mean   :45.50   Mean   :55.50   Mean   :65.50   Mean   :75.50  
##  3rd Qu.:47.75   3rd Qu.:57.75   3rd Qu.:67.75   3rd Qu.:77.75  
##  Max.   :50.00   Max.   :60.00   Max.   :70.00   Max.   :80.00  
##      grupo9         grupo10      
##  Min.   :81.00   Min.   : 91.00  
##  1st Qu.:83.25   1st Qu.: 93.25  
##  Median :85.50   Median : 95.50  
##  Mean   :85.50   Mean   : 95.50  
##  3rd Qu.:87.75   3rd Qu.: 97.75  
##  Max.   :90.00   Max.   :100.00

Lista

Uma lista é um objeto que consiste de um conjunto de dados com modos diferentes ordenados de forma hierárquica. Por exemplo, é possível construir uma lista com uma matriz, um vetor lógico etc.

loboG <- list(Nome = "Lobo Guará", Reino = "Animalia", Filo = "Chordata", Classe = "Mammalia", Ordem = "Carnivora", Família = "Canidae", Gênero = "Chrysocyon", Espécie = "C. brachyurus", NomeB = "Chrysocyon brachyurus"); loboG
## $Nome
## [1] "Lobo Guará"
## 
## $Reino
## [1] "Animalia"
## 
## $Filo
## [1] "Chordata"
## 
## $Classe
## [1] "Mammalia"
## 
## $Ordem
## [1] "Carnivora"
## 
## $Família
## [1] "Canidae"
## 
## $Gênero
## [1] "Chrysocyon"
## 
## $Espécie
## [1] "C. brachyurus"
## 
## $NomeB
## [1] "Chrysocyon brachyurus"

Data Frame

Parecido com uma matriz, a única diferença é que este tipo de objeto aceita vetores de tipos diferentes, por causa dessa característica o data frame é o tipo de objeto mais utilizado no R

comunidade <- data.frame(especies = c("D.nanus", "S.alter","I.guentheri", "A. callipygius"), habitat = factor(c("Folhiço", "Arbóreo", "Riacho", "Poça")), altura = c(1.1, 0.8, 0.9, 1), distancia = c(1, 1.7, 0.6, 0.2)); comunidade
##         especies habitat altura distancia
## 1        D.nanus Folhiço    1.1       1.0
## 2        S.alter Arbóreo    0.8       1.7
## 3    I.guentheri  Riacho    0.9       0.6
## 4 A. callipygius    Poça    1.0       0.2
knitr::kable(comunidade)
especies habitat altura distancia
D.nanus Folhiço 1.1 1.0
S.alter Arbóreo 0.8 1.7
I.guentheri Riacho 0.9 0.6
A. callipygius Poça 1.0 0.2 
DT::datatable(comunidade)
class(comunidade)
## [1] "data.frame"
str(comunidade)
## 'data.frame':    4 obs. of  4 variables:
##  $ especies : chr  "D.nanus" "S.alter" "I.guentheri" "A. callipygius"
##  $ habitat  : Factor w/ 4 levels "Arbóreo","Folhiço",..: 2 1 4 3
##  $ altura   : num  1.1 0.8 0.9 1
##  $ distancia: num  1 1.7 0.6 0.2
fix(comunidade)
edit(comunidade)
##         especies habitat altura distancia
## 1        D.nanus Folhiço    1.1       1.0
## 2        S.alter Arbóreo    0.8       1.7
## 3    I.guentheri  Riacho    0.9       0.6
## 4 A. callipygius    Poça    1.0       0.2

O símbolo $ é o responsável pela seleção das colunas de um data frame, antes do $ vem o nome do objeto, depois, o nome da coluna.

Operações no R

+ Soma unária, ou binária entre dois vetores
- Subtração pode ser unária ou binária
* Multiplicação entre dois vetores
/ Divisão entre dois vetores
^ ou ** Exponenciação binária, isto é 2^5 ou 2 ** 5
% / % Divisão inteira
%% Restante da divisão
sum() Soma de elementos
prod() Produto dos elementos
sqrt() Raiz quadrada
log() Função Logaritmo Neperiano
log10() Função Logaritmo na base 10
log(x, base = y) Logaritmo na base y do vetor ou escalar x
exp() Função exponencial
mean() Média
sd() Descio padrão
var() Variância
median() Mediana
round() Arredondamento de vetor numérico. Outros tipos são: trunc(), floor() e ceiling()
signif(x, digits = n) Arredondamento de vetor numérico. Outros tipos são: trunc(), floor() e ceiling()
ceiling() Arredonda o valor do vetor para o maior valor
floor() Arredonda o valor para o menor valor
factorial() Fatorial
trunc() Trunca (corta) as decimais do vetor
length() Retorna o tamanho do vetor
sort() Retorna o vetor com os valores em ordem crescente
max() Retorna o valor máximo do vetor
min() Retorna o valor mínimo do vetor
range() Retorna a amplitude do vetor
summary() Sumário estatístico do vetor
aov(y ~ x, data = d) Análise de variância unidirecional do quadro de dados d. Variável dependente (y) variável independente (x)
aov(y ~ x*z, data = d) Análise de variância bidirecional
cor(x, y) Coeficiente de correlação
cor.teste(x, y) Retorna o coeficiente de correlação com um teste-t de significância
lm(y ~x, data = d) Análise de regressão linear

Resumo de Funções

Vetor Matriz Array
names() rownames(), colnames() dimnames()
length() nrow(), ncol() dim()
c() rbind(), cbind() abind::abind()
- t() aperm()
is.null(dim(x)) is.matrix() is.array

Operadores Lógicos

Operadores Lógicos Sintaxe Pergunta
< a < b a é menor que b
> a > b a é maior que b
== a == b a é igual a b
!= a != b a é diferente de b
>= a >= b a é maior ou igual a b
<= a <= b a é menor ou igual a b
%in% “a” %in% c(“a”, “b”, “c”) O elemento “a” está no vetor c(“a”, “b”, “c”)?

Operadores Booleanos

Operadores Booleanos Sintaxe Pergunta
& ou && cond1 & cond2 As cond1 e cond2 são verdadeiras?
| ou || cond1| cond2 A cond1 ou cond2 é verdadeira?
xor() xor(cond1, cond2) Apenas a cond1 ou a cond2 é verdadeira?
! !cond1 É falso a cond1?
any() any(cond1, cond2, …) Algumas das condições são verdadeiras?
all() all(cond1, cond2, …) Todas as condições são verdadeiras? 
notas.dos.alunos <-c (6.0,5.1,6.8,2.8,6.1,9.0,4.3,10.4,6.0,7.9,8.9,6.8,9.8,4.6,11.3,8.0,6.7,4.5)

Quantos valores iguais ou maiores que cinco? sum(notas.dos.alunos>=5)

Quantos alunos tiraram abaixo de 5? E abaixo de 4?

Qual a proporção deste valores em relação ao total?

sum(notas.dos.alunos>=5)/length(notas.dos.alunos)
## [1] 0.7777778

Como saber a quantidade dos dados utilizando a função sum() com os operadores? Não vale utilizar a função length.

sum(notas.dos.alunos!=0)
## [1] 18

Importando dados no RStudio

O formato UNIVERSAL de tabela de dados para análise estatística é o seguinte: cada LINHA é uma observação e cada COLUNA é uma variável ou atributo que foi tomado em cada observação. Existem diversas maneiras para importar os dados no programa R, Alguns dos formatos mais utilizados são:

  • CSV (Comma separated values), HTML, XML, json, HDF5, Arquivos Xls (EXCEL), Dados em tabela, Dados espaçados por TAB, linhas de arquivos de texto, SPSS, Stata)…

O modelo CSV é o mais utilizado para armazenar informações em tabelas, porque é feito diretamente no EXCEL. Nesse modelo o separador (vírgula, ponto e vírgula) indica a passagem para a próxima coluna e a tabela pode ter um cabeçalho (Header) com os nomes das colunas ou não. O arquivo de texto com extensão .txt, geralmente usa espaços. Isso acaba gerando problema de leitura no R, porque muitos usuários usam nomes de variáveis muito grandes, palavras compostas, de forma a desalinhar as colunas das variáveis. Daí, como a separação das variáveis é por meio de espaços, acaba gerando problema de leitura.

A função primária responsável pela importação de dados é a função scan(), as funçõesread.table(),read.csv() e read.delim(), usam a funçãoscan()em seu algoritmo. A primeira ideia sobre importação de dados pode ser inserindo-os pelo teclado no próprio ambiente R. Para isso, usaremos a função scan(). Vejamos:

o <- scan()

Após executado essa linha de comando, aparecerá no console 1: que significa, digitar o primeiro valor do objeto x, e depois clicar em ENTER. Depois 2:, que significa digitar o segundo valor, e clicar em ENTER. Depois de inserido todos os valores necessários, aperte a tecla ENTER duas vezes no console, para sair da função scan().

O modo mais simples de importar dados no RStudio é pelo botão Import Dataset, na aba Environment. Após esse comando podemos configurar a leitura do banco de dados, já que uma prévia de como os dados serão representados estará disponível no quadro Data Frame, se encontrarmos quaisquer problemas devemos resolvê-lo nas opções adicionais como utilizar outro separador, símbolos para casas decimais etc. Por fim é só digitar o nome do objeto e clicar no botão import.

dados_times <- read.csv("tabela.csv", header = T)

Por definição essa função abre arquivos que foram salvos utilizando a vírgula como separador, read.csv2 (abre arquivos que foram delimitados por ; )

Para saber qual o separador foi utilizado basta somente abrir o arquivo com o Bloco de Notas.

Utilizamos a função com header = TRUE já que neste CSV, a primeira linha indica o nome das colunas, ou seja, é seu cabeçalho (seu header). Caso utilizássemos header = FALSE, os valores constantes na primeira linha não seriam os nomes das colunas.

O argumento dec=“.” quer dizer foi usado “.” na parte decimal dos dados originalmente digitados, sep = “\t” quer dizer que quando o arquivo foi salvo com a extensão .txt, optou-se pelo separador de colunascom tabulação.

Também podemos copiar e colar valores diretamente de arquivos, como .pdf ou .docx, através do comando read.delim.

Ctrl+V:

tabela <- read.delim("clipboard", row.names=1)

Manipulação Gráfica

O programa R possui uma interface gráfica que funciona através de comandos e argumentos: Tipos de gráficos: barplot(); pie(); hist(); plot().

Rótulos: main = “nome”, xlab = “nome”, ylab = “nome”

Tamanho dos caracteres: ‘cex’ (character expansion)

Titulo: use ’cex.main=valor.

Para os eixos, use o argumento ‘cex.axis=valor’.

Para o nome dos eixos, use ‘cex.lab=valor’.

Cores: col=‘blue’

Símbolo do plot (circulo, quadrado,…) usa-se o ‘pch’.

Molduras do gráfico: bty=“L”- retira as molduras direita e superior; box()- adiciona moldura.

Limite das escalas dos eixos: ‘xlim’ e ‘ylim’.

Linhas, pontos: arrows() - adiciona seta; lines() - adiciona linha; points()- adiciona pontos.

Legenda: legend()

Para inserir um texto dentro do gráfico, utilize o comando “text”

text(posição eixo X, posição eixo Y, “texto a inserir”, outros argumentos)

Para inserir um texto fora da área do gráfico, utilize o comando “mtext”

mtext(“texto”, side = posição, line = posição, adj = posição entre esquerda(0) e direita (1)

Para salvar gráficos no R em resolução máxima utilizamos o seguinte comando antes de plotar os gráficos:

tiff("arquivo.tif", res = 300, type = "windows", width = 3000, height = 2000)


plota o gráfico e encerra com

dev.off()

OU

png(filename="teste.png", height=8, width=16, unit="cm", res=300)

#Argumento mfrow (colunas,linhas), argumento mar faz referência aos tamanhos dos espaços no gráfico; par(mfrow=c(1,2),mar=c(1,1,1,1), oma=c(1,1,0,0))

GGPLOT2

É um pacote gráfico que faz parte da coleção de pacotes chamada tidyverse destinada para Análise de Dados. A Principal característica desse pacote é que ele descreve um gráfico a partir dos seus componentes, como se fossem camadas. Ggplot Card

data("iris"); head(iris); str(iris); class(iris); colnames(iris); install.packages("ggplot2"); library(ggplot2)

ggplot(iris, aes(Petal.Length, Petal.Width, color = Species, shape = Species)) +

geom_point(fill = "black", size = 2, stroke = 1) +

scale_color_manual(values = c("purple", "yellow", "green")) +

scale_shape_manual("Species", values = c(19, 21, 22))+

scale_x_continuous(name = "Comprimento da Pétala", breaks = 1:7) +

scale_y_continuous(name = "Largura da Pétala", breaks = 0:3, limits = c(0, 3)) +

labs(title = 'Relação entre o Comprimento e Largura da pétala de três spp da flor Iris')

Resultado:

Mapeamento Estético

Responsável pela personalização visual do gráfico

Função aes()

Posição (x e y);

Cor (color);

Tamanho (size);

Preenchimento (fill);

Transparência (alpha);

Texto (label).

Forma (shape)

Objeto Geométrico: Tipo de Gráficos

Função geom_ + Tipo do objeto

Dispersão (scatterplot): geom_point()

Gráfico de bolhas: geom_point()

Gráfico de barras: geom_bar() e geom_col()

Histograma: geom_histogram()

Boxplot: geom_boxplot()

Densidade: geom_density()

Gráfico de linhas: geom_line()

Funções

Aqui desenvolveremos e conheceremos mais a fundo o princípio da função do R, segundo o primeiro princípio (princípio do objeto) a função também é um objeto e elas são constituídas por três componentes: Argumentos (função formals()), Corpo (função body()) e o Ambiente (função environment()).

Podemos consultar os três componentes da função aov.

formals(aov); body(aov); environment(aov)
## $formula
## 
## 
## $data
## NULL
## 
## $projections
## [1] FALSE
## 
## $qr
## [1] TRUE
## 
## $contrasts
## NULL
## 
## $...
## {
##     Terms <- if (missing(data)) 
##         terms(formula, "Error")
##     else terms(formula, "Error", data = data)
##     indError <- attr(Terms, "specials")$Error
##     if (length(indError) > 1L) 
##         stop(sprintf(ngettext(length(indError), "there are %d Error terms: only 1 is allowed", 
##             "there are %d Error terms: only 1 is allowed"), length(indError)), 
##             domain = NA)
##     lmcall <- Call <- match.call()
##     lmcall[[1L]] <- quote(stats::lm)
##     lmcall$singular.ok <- TRUE
##     if (projections) 
##         qr <- lmcall$qr <- TRUE
##     lmcall$projections <- NULL
##     if (is.null(indError)) {
##         fit <- eval(lmcall, parent.frame())
##         fit$call <- Call
##         structure(fit, class = c(if (inherits(fit, "mlm")) "maov", 
##             "aov", oldClass(fit)), projections = if (projections) 
##             proj(fit))
##     }
##     else {
##         if (pmatch("weights", names(Call), 0L)) 
##             stop("weights are not supported in a multistratum aov() fit")
##         deparseb <- function(expr) deparse1(expr, backtick = TRUE)
##         opcons <- options("contrasts")
##         options(contrasts = c("contr.helmert", "contr.poly"))
##         on.exit(options(opcons))
##         allTerms <- Terms
##         errorterm <- attr(Terms, "variables")[[1L + indError]]
##         intercept <- attr(Terms, "intercept")
##         ecall <- lmcall
##         ecall$formula <- as.formula(paste(deparseb(formula[[2L]]), 
##             "~", deparseb(errorterm[[2L]]), if (!intercept) 
##                 "- 1"), env = environment(formula))
##         ecall$method <- "qr"
##         ecall$qr <- TRUE
##         ecall$contrasts <- NULL
##         er.fit <- eval(ecall, parent.frame())
##         options(opcons)
##         nmstrata <- attr(terms(er.fit), "term.labels")
##         nmstrata <- sub("^`(.*)`$", "\\1", nmstrata)
##         nmstrata <- c("(Intercept)", nmstrata)
##         qr.e <- er.fit$qr
##         rank.e <- er.fit$rank
##         if (rank.e < NROW(er.fit$coefficients)) 
##             warning("Error() model is singular")
##         qty <- er.fit$residuals
##         maov <- is.matrix(qty)
##         asgn.e <- er.fit$assign[qr.e$pivot[1L:rank.e]]
##         maxasgn <- length(nmstrata) - 1L
##         nobs <- NROW(qty)
##         len <- if (nobs > rank.e) {
##             asgn.e[(rank.e + 1L):nobs] <- maxasgn + 1L
##             nmstrata <- c(nmstrata, "Within")
##             maxasgn + 2L
##         }
##         else maxasgn + 1L
##         result <- setNames(vector("list", len), nmstrata)
##         lmcall$formula <- form <- update(formula, paste(". ~ .-", 
##             deparseb(errorterm)))
##         Terms <- terms(form)
##         lmcall$method <- "model.frame"
##         mf <- eval(lmcall, parent.frame())
##         xlev <- .getXlevels(Terms, mf)
##         resp <- model.response(mf)
##         qtx <- model.matrix(Terms, mf, contrasts)
##         cons <- attr(qtx, "contrasts")
##         dnx <- colnames(qtx)
##         asgn.t <- attr(qtx, "assign")
##         if (length(wts <- model.weights(mf))) {
##             wts <- sqrt(wts)
##             resp <- resp * wts
##             qtx <- qtx * wts
##         }
##         qty <- as.matrix(qr.qty(qr.e, resp))
##         if ((nc <- ncol(qty)) > 1L) {
##             dny <- colnames(resp) %||% paste0("Y", 1L:nc)
##             dimnames(qty) <- list(seq(nrow(qty)), dny)
##         }
##         else dimnames(qty) <- list(seq(nrow(qty)), NULL)
##         qtx <- qr.qty(qr.e, qtx)
##         dimnames(qtx) <- list(seq(nrow(qtx)), dnx)
##         for (i in seq_along(nmstrata)) {
##             select <- asgn.e == (i - 1L)
##             ni <- sum(select)
##             if (!ni) 
##                 next
##             xi <- qtx[select, , drop = FALSE]
##             cols <- colSums(xi^2) > 1e-05
##             if (any(cols)) {
##                 xi <- xi[, cols, drop = FALSE]
##                 attr(xi, "assign") <- asgn.t[cols]
##                 fiti <- lm.fit(xi, qty[select, , drop = FALSE])
##                 fiti$terms <- Terms
##             }
##             else {
##                 y <- qty[select, , drop = FALSE]
##                 fiti <- list(coefficients = numeric(), residuals = y, 
##                   fitted.values = 0 * y, weights = wts, rank = 0L, 
##                   df.residual = NROW(y))
##             }
##             if (projections) 
##                 fiti$projections <- proj(fiti)
##             class(fiti) <- c(if (maov) "maov", "aov", oldClass(er.fit))
##             result[[i]] <- fiti
##         }
##         structure(class = c("aovlist", "listof"), result[!vapply(result, 
##             is.null, NA)], error.qr = if (qr) 
##             qr.e, call = Call, weights = if (length(wts)) 
##             wts, terms = allTerms, contrasts = cons, xlevels = xlev)
##     }
## }
## <environment: namespace:stats>

O Corpo da função é onde está detalhadamente escrito a instrução necessária para que o programa execute determinada ação, podemos verificar o corpo de qualquer função no RStudio escrevendo apenas seu nome no console.

Chamadas de Funções:

Podemos executar qualquer chamada de função de três maneiras, sendo elas: aninhada, intermediária e pelo operador pipe.

Primeiro iremos criar um conjunto com 50 números aleatórios provenientes de uma distribuição normal (para padronizarmos os dados, vamos enraizar o resultado executando a função set.seed(5)) em seguida iremos calcular o desvio padrão para esses dados de três maneiras.

set.seed(5); dados_normais <- rnorm (50)
  • Função Aninhada:
sqrt(var(dados_normais))
## [1] 1.068682
  • Função Intermediária:
variancia <- var (dados_normais)
desvio_padrao <- sqrt(variancia); desvio_padrao
## [1] 1.068682
  • Operador Pipe: Podemos utilizar esse operador através do pacote magrittr (%>%) ou pela função nativa ( |> ) do R que foi implementada após a versão >= 4.1 do R.
dados_normais |>
  var()|>
  sqrt()
## [1] 1.068682

A função aninhada possui sua ordem de execução da direita para a esquerda e a principal vantagem dessa forma sintática é que não precisamos associar nomes aos objetos na hora da execução da função como fazemos na forma tradicional que é a intermediária. Por fim, a sintática do operador pipe é a mais complexa para assimilar, o operador especial tem como primeiro operando o primeiro argumento da função no segundo operando.

Estruturas de Controle

As estruturas de controle são extremamente necessárias na hora da execução de uma ação através de qualquer linguagem de programação. Elas se referem a ordem com que as instruções fornecidas são executadas ou avaliadas em programas de computador. A ideia geral de funcionamento dessas funções é


função (condição { expressão}

  • if(): Se quisermos executar um determinado código apenas se a condição for verdadeira e se a condição for falsa, queremos que nada seja feito, então:

if (condição) {
comandos a serem executados caso a condição nos parênteses seja verdadeira
}

i <- 5
if (i > 3){
  print("Maior que 3!")
}
## [1] "Maior que 3!"

Caso desejamos uma resposta alternativa quando a condição for falsa utilizamos o else()

if (condição) { expressão sob condição = TRUE} else { expressão sob condição = FALSE}

if (is.numeric(i)) {
  print("Isso é um número")
} else {
  print("Isso não é um número")
}
## [1] "Isso é um número"
if (is.character(i)) {
  "palavra"
} else {
  if ((i %% 2) == 0) {
    "número par"
  } else {
    if ((i %% 2) == 1) {
      "número ímpar"
    }
  }
}
## [1] "número ímpar"
  • Ifelse()Sintaxe: ifelse (Condição , comando executado caso a condição seja verdadeira , comando executado caso a condição seja falsa)
r <- 4
g <- 6
ifelse(r > g, print(paste("O maior número é:", r)), print(paste("O maior número é:", g)))
## [1] "O maior número é: 6"
## [1] "O maior número é: 6"

  • As três estruturas de repetição no R são: repeat, while e for e são utilizadas para loop no programa.

  • for()

Função que repete o código seguinte para o comprimento da sequência indicada entre parênteses.

Sintaxe: for (variável in sequência) {
comandos a serem repetidos
}

for (i in 1:10) {
  print(i)
}
## [1] 1
## [1] 2
## [1] 3
## [1] 4
## [1] 5
## [1] 6
## [1] 7
## [1] 8
## [1] 9
## [1] 10
  • while()

A tradução desta função nos ajuda a entendê-la mais: while significa enquanto. Então podemos ler essa função como: Enquanto alguma condição for verdadeira, o código abaixo será repetido.

Sintaxe: while (condição){
comandos a serem repetidos
}

k <- 1
while (k <= 10) {
  print((k))
  k <- k + 1
}
## [1] 1
## [1] 2
## [1] 3
## [1] 4
## [1] 5
## [1] 6
## [1] 7
## [1] 8
## [1] 9
## [1] 10

Note que os dois últimos exemplos resultam na mesma coisa: o R vai retornar os números de 1 a 10 em sequência. Porém nós precisamos mudar o valor de a para que a sequência continue no caso do while() enquanto no for() a sequência progride sem precisarmos fazer isso manualmente. Além disso, ao usar while() precisamos declarar a variável antes para que o R possa testar a condição expressa dentro dos parênteses.

  • repeat()

Usando este comando, o R repetirá o código a seguir sem condições. Com isso, precisamos de mais uma função para mostrar ao programa quando deve parar de repetir o código. A função que faz isso é break(). Como sempre existe uma condição a ser satisfeita para o código continuar a ser repetido ou parar, então devemos também usar a função if().

Sintaxe:

repeat {
Comandos a serem repetidos
if (Condição para que a repetição pare) break()
}

js <- 1
repeat {
  print(js)
  js <- js + 1
  if (js > 10) break ()
  }
## [1] 1
## [1] 2
## [1] 3
## [1] 4
## [1] 5
## [1] 6
## [1] 7
## [1] 8
## [1] 9
## [1] 10

Neste exemplo obtivemos o mesmo resultado dos anteriores. Note que com o repeat, além de termos que ir aumentando o valor da variável manualmente, também precisamos especificar qual a condição para que o loop pare de ser realizado. Assim como quando usamos while(), aqui também precisamos declarar a variável antes.

Criando Funções

Todas as funções utilizadas até agora no RStudio foram funções já desenvolvidas para o R provenientes de pacotes, algumas delas já são implementadas no programa como o pacote base e outras devem ser baixadas e anexadas ao programa para sua utilização, como é o caso de vários pacotes estatísticos disponíveis no CRAN.

Podemos desenvolver nossas próprias funções através do uso do function() na qual é um objeto que possui o modo closure, que possui sua sintaxe da seguinte forma:

funçãoX <- function(args1, args2, …) {
corpo: comandos..
}

funçãoX <- function(x) {
  rest <- x + 1
  return(rest)
}
funçãoX(x = 24)
## [1] 25

Observamos que criamos uma função chamada funçãoX, cujo argumento de entrada é x. Observe que uma função é como um objeto do tipo vetor, associamos um nome ao objeto da mesma forma. O corpo apresenta uma delimitação por chaves {…}, em que apresenta um comando de atribuição res que se associa a soma x + 1, e por fim, o resultado dessa função, imprime res, por meio da função return().

formals(funçãoX)
## $x
body(funçãoX)
## {
##     rest <- x + 1
##     return(rest)
## }
environment(funçãoX)
## <environment: R_GlobalEnv>

Escopo Léxico

Observamos que o terceiro componente de uma função do tipo closure é o seu Ambiente, no exemplo acima este ambiente é chamado de ambiente envolvente (ambiente global) esse ambiente representa o lugar onde a função desenvolvida se associou ao seu nome que no nosso caso é funçãoX, mas quando a função é executada, momentaneamente é criado um Ambiente de Execução na qual os nomes que estão no corpo da função serão associados aos objetos.

bw <- 25
fun <- function() {
  bw <- 2
  bw
}
fun()
## [1] 2

Por causa do ambiente de execução que o objeto x dentro da função é retornado, ao invés do que foi definido fora da função. Isso porque o ambiente de execução mascara os nomes definidos dentro da função dos nomes definidos fora da função. Esse é uma primeira característica do escopo léxico nas funções em R.

Anteriormente, falamos sobre a atribuição ( <- ), que representa a forma como os nomes se associam aos objetos. Agora, o escopo vem a ser a forma como os nomes encontram seus valores associados. O termo léxico significa que as funções podem encontrar nomes e seus respectivos valores associados, definidos no ambiente onde a função foi definida, isto é, no ambiente de função. Claro que isso segue regras, e a primeira foi a máscara de nome falada anteriormente.

Porém quando não existe um nome vinculado a um objeto, e este foi definido no ambiente de função, o valor é repassado para o corpo da função.

bw <- 25
fun <- function() {
  bw
}
fun()
## [1] 25

Diferente do resultado acima, agora, o resultado da execução do comando foi 25, porque como a função procurou no ambiente de execuções e não encontrou esse nome, a função foi até o ambiente superior, no caso, o ambiente global. Todo ambiente tem um pai (ou ambiente superior). Essa hierarquização é observada no caminho de busca, que pode ser acessado por search(), ou seja,

search()
## [1] ".GlobalEnv"        "package:stats"     "package:graphics" 
## [4] "package:grDevices" "package:utils"     "package:datasets" 
## [7] "package:methods"   "Autoloads"         "package:base"

O ambiente corrente do R sempre será o ambiente ambiente global (.GlobalEnv). O ambiente de execução não aparece, porque ele é momentâneo.

Dicas para melhorar a sintaxe no R.

Para facilitar nossa compreensão sobre as linhas de comando desenvolvidas no R é aconselhável realizar essas configurações no RStudio que se referem ao diagnóstico do código escrito:

Tools > Global options > Code > Editing. Marque todas as opções em General;

Tools > Global options > Code > Display, Marque todas as opções;

Tools > Global options > Code > Diagnostics. Marque todas as opções em R Diagnostics.

Com essas configurações as linhas de comando estarão estruturadas com cores que distinguem diversas estruturas como funções, espaçamentos etc.

Melhorando o Script

Existem alguns pacotes que automatizam a forma que organizamos nossas linhas de comando, o pacote styler (função styler:::style_active_file()) e o formatR formatam nossas linhas de comando contidas em um diretório ou scrip para facilitar a compreensão sintática dos comandos. para mais exemplos acesse a página

Um dos erros mais comuns na sintaxe de um código é o seu espaçamento, no geral devemos colocar espaçamento entre a maioria dos operadores básicos do R, exceto pelos operadores :, :: e :::, e sempre é recomendado utilizar um espaço após a vírgula. Podemos exemplificar como seria a sintaxe ideal para determinado comando, vamos utilizar a seguinte linha de comando como exemplo:

fun1<-"desviopadrao<-sqrt(var(dados_normais))"

Observamos que a forma sintática utilizada nesse comando está bastante confusa sem os devidos espaçamentos, para verificarmos a melhor forma que poderíamos escrever esse comando é só utilizar a função style_text(fun1), do pacote style, mas antes de executar essa função no RStudio precisaremos instalar 3 pacotes que são: styler, prettycode e rstudioapi, para tanto, vamos utilizar a função combine c():

install.packages(c("prettycode", "styler", "rstudioapi"))

Em seguida iremos utilizar o comando styler::style_text(fun1)

styler::style_text(fun1)
## desviopadrao <- sqrt(var(dados_normais))
comando <- "media<-mean(x+1/length(x),na.rm=TRUE)"
styler::style_text(comando)
## media <- mean(x + 1 / length(x), na.rm = TRUE)

Utilizando chaves

Quando usamos chaves em um comando, devemos evitar abri-lo e fechá-lo na mesma linha. E ainda, quando é função, as linhas de comando inseridas dentro das chaves, inserimos um recuo de dois espaços para entendermos a hierarquização das funções, isto é, função dentro de função.

No demais, devemos estar atentos em não nomear nossos objetos com os nomes existentes no programa, para verificar se determinado nome já está associado a algum objeto basta utilizar a função exists(), por exemplo: exists(“aov”) se a função retornar com o TRUE, significa que tal nome já está associado a determinado objeto no programa, devemos utilizar nomes curtos e comentar cada linha de comando com o uso do # para facilitar o entendimento posteriormente a criação da rotina.

O que é um Pacote?

Basicamente um pacote é um diretório de arquivos necessários para rodar determinado conjunto de códigos, funções, dados, documentação de ajuda etc. O programa R em sua forma mais básica possui 30 pacotes que são fundamentais para a utilização plena do programa. Existem mais ou menos 17.300 pacotes disponíveis no CRAN. O objetivo básico de um pacote é automatizar rotinas no R, digamos que para um pesquisador calcular o desvio padrão, intervalo de confiança e realizar uma anova nos seus dados ele precise escrever um série de rotinas no programa R, se esse mesmo pesquisador decidir aplicar a mesma metodologia para outro conjunto de dados ele teria que refazer todas as linhas de comando novamente ocasionando trabalhos desnecessários, por outro lado, com a criação de pacotes estatísticos o pesquisador já tem em mãos rotina já prontas esperando apenas algumas linhas de comando para rodar toda a análise.

A estrutura básica de um pacote é composta pelos seguintes “arquivos”:

  • DESCRIPTION: que é basicamente um arquivo de texto contendo todas as informações descritivas sobre o pacote.

  • NAMESPACE: serve para destinar a importação e exportação de funções no pacote, ele dita quais funções serão exportadas na hora do carregamento do pacote pela função library() ou require().

  • R/: é um subdiretório contendo todos os scrips com as funções em R, basicamente é o cérebro do pacote

  • Man/: esse subdiretório apresenta os arquivos de ajuda (.Rd).

Instalando e Carregando Pacotes

A Função que instala pacotes no R é a install.packages(). E um dos pacotes mais utilizados no R é o vegan, ele foi criado por vários pesquisadores e tem o propósito de rodar várias análises no âmbito da ecologia, como Índices de Diversidade, Métodos de Ordenação, Análise da Diversidade e outras funções para ecólogos de comunidade.

Install.packages("vegan")

Podemos instalar vários pacotes simultaneamente utilizamos a função c() para criar um vetor: install.packages(c("vegan","sos"))

Para carregar o pacote utilizamos a função library(Nome do Pacote Desejado)

Podemos acessar os dados contidos nos pacotes através do argumento data()

Usando os Operadores :: e :::

Para executarmos uma função de um determinado pacote sem a necessidade de carregar o pacote (library(pacote)) utilizamos o operador ::, contudo se conhecemos a estrutura de um pacote e sabemos que o pacote contém função não exportadas pelo namespace basta utilizar o comando ::: para carregar essas funções, mas não recomendamos a utilização de funções internas no desenvolvimento de pacotes uma vez que tais funções podem passar por mudanças se os desenvolvedores atualizarem algum índice etc.