Introdução à Linguagem R

O que é:

• A versão livre da linguagem SPlus, que é uma linguagem de programação desenvolvida especialmente para a Estatística;
• É uma linguagem de Script: Fracamente tipada, e uma linguagem interpretada;
• É uma linguagem multiplataforma, existe tanto para Windows como para Unix.

obs. O principal problema da linguagem R é que ela não segue certas convenções de nomes de funções e de simbologia comuns a vários softwares de estatística e outras linguagens de programação.

O Ambiente de Programação

Ao iniciar o interpretador, surge uma janela com o sinal > para indicar o ponto onde se deve inserir os comandos.

Para sair do interpretador digite a função

> q()

A letra q de quit ("terminar" em inglês), sequido de abre e fecha parêntesis, depois pressione enter. O interpretador perguntará se deseja guardar as variáveis de ambiente. Responda sempre NÃO até entender para que serve isso.

Os comandos da linguagem (até agora só vimos um: o comando de sair do interpretador) podem ser separados por uma quebra de linha, ou pelo caracter ; (ponto e vírgula).

Sempre que se muda de linha, mas o comando não terminou de ser digitado, aparecerá o símbolo + no início da linha, para indicar que o interpretador espera que o restante do comando seja digitado.

Para que uma linha, ou a parte final de uma linha seja ignorada pelo interpretador, use o caracter # . A parte da linha protegida por esse caracter chama-se comentário. Normalmente isso é usado para explicar para a pessoa que está olhando o programa o que a linha faz. É um bom hábito escrever comentários em programas, pois isso permite que se entenda melhor o que foi feito quando o programa é revisto no futuro.

Para obter uma página de ajuda use o comando

> help.start()

Esse comando abrirá o navegador e apresentará uma página (em ingles) com links para tutoriais e ajudas sobre várias funções.

Tipos de Dados

• Inteiros: 4 6 104 etc.
• Reais: 2.55 3.1414 1.45 etc. Note que para a separação das casas decimais usa-se o PONTO.
• String (cadeias de caracteres): "idade" "estado de origem" "outro exemplo" . Note que usa-se as aspas duplas para indicar uma string. Isso é feito para que elas não sejam confundidas com comandos e outros elementos da linguagem.
• Lógico: TRUE (verdadeiro) ou FALSE (falso)
• Constante: NaN (not-a-number), NULL (nulo), NA (not available), Inf (infinito)

Operações Aritméticas

As operações aritméticas podem ser digitadas diretamente no interpretador, nesse caso o cálculo será executado e o resultado será apresentado na linha seguinte, logo após o indicador do número da linha de saída. Por exemplo para somar 2 com 3 digite

> 2+3

[1] 5

O [1] indica a linha da saída (que só possui uma nesse exemplo) e o resultado é 5.

As seguintes operações aritméticas são reconhecidas:

Exemplos:

> 6-8 # a resposta é -2

> 2*10 # a resposta é 20

> 5/2 # a resposta é 2.5

> 5%%2 # a resposta é 1

>5%/%2 # a resposta é 2

Operações Lógicas

Exemplos:

> 3 < 2 # o resultado é FALSE

> (3>2) &&(5<7) # o resultado é TRUE

Funções Matemáticas Elementares

Variáveis

Atribuição:

As variáveis são criadas no momento da sua primeira atribuição. Note que não se especifica o tipo da variável, O tipo da variável é deduzido a partir da atribuição.

nome_da_variável <- valor

ou

nome_da_variável = valor # essa notação não é reconhecida em todas as implementações da linguagem

ou

valor -> nome da variável

Exemplo: Todas as tres linhas atribuem o valor 2 (inteiro) à variável x.

> x <- 2

> x = 2

> 2 -> x

Para indicar que a variável é do tipo real use x <- 2.0

Identificadores:

Os nomes das variáveis são identificadores, isto é, nomes criados pelo próprio usuário para dar nome a um elemento, que pode ser uma variável ou função. As regras para criaçao de identificadores são:

1. Devem ser compostos pelas letras A até Z, a até z, 0 até 9, _ (underline), e . (ponto). Algumas implementações aceitam letra acentuada;
2. Tem que começar por letra ou . (ponto), e se começar por ponto o caractere seguinte tem que ser uma letra ou ponto;
3. Letras maiúsculas e minúsculas são consideradas distintas, assim x2 e X2 são identificadores diferentes.

Exemplo:

Pode: x .p ..p n.2 Goiás Catalão (note o acento)

Não pode: _x 2n .21

Sequências

Uma Sequência (chamado no suporte interno de Vector), é, como o nome diz,  uma sequência ordenada de valores, para os quais é atribuido um nome. Para se criar uma Sequência usa-se a função c (abreviação de "concatenação") da seguinte forma.

nome_da_sequência <- c(valor1, valor2, ..., valor n)

Exemplo:

> idade <- c(10, 20, 10, 5, 8, 13, "não sei", NA) # cria uma sequência chamada "idade" com alguns números ( idades), uma string e um valor indefinido (NA)

1. Os valores podem ser de tipos diferentes;
2. Os valores podem ser NA, indicando que não existe a informação

Length

A função length retorna o tamanho da sequência. Exemplo:

> length(idade) # retorna 8

Sequências Regulares

É comum a necessidade de se gerar sequências longas mas que possuem uma lei de formação. As maneiras de se gerar uma sequência a partir da lei de formação são as seguintes:

limite_inicial : limite_final

Gera uma sequência de números inteiros do limite_inicial até o limite_final.

exemplo

> 4:10 # gera 4, 5, 6, 7, 8, 9, 10

>12:7 # gera 12, 11, 10, 9, 8, 7

A função seq()

Usa-se a função seq() quando se deseja gerar uma sequência com um incremento (ou decremento) diferente de 1. Essa função possui dois argumentos opcionais que merecem destaque: o argumento "by" que permite especificar o tamanho do incremento, e o parâmetro "length" que permite especificar o tamanho da sequência.

exemplo:

> seq(4,10) # gera 4 5 6 7 8 9 10

> seq(4,10,length=5) # gera 4.0 5.5 7.0 8.5 10.0

> seq(4, 10, by=2) # gera 4 6 8 10

> seq(4, by=2, length=5) # gera 4 6 8 10 12

Funções Estatísticas

Operações com Sequências

1. As operações aritiméticas, quando usadas com sequências, são executadas elemento-a-elemento, e o resultado é uma nova sequência.

Exemplo:

> peso <- c(60, 80, 100, 80)

> altura <- c(1.60, 1.80, 2.00, NA)

> peso/altura^2

[1] 23.43750 24.69136 25.00000 NA

2. Se uma operação é feita entre uma constante e uma sequência, a operação com a constante será aplicada elemento-a-elemento.

Exemplo:

> altura-1

[1] 0.6 0.8 1.0 NA

> 2*peso

[1] 120 160 200 160

3. Se uma função matemática é aplicada a uma sequência, essa função é aplicada a cada elemento individualmente da sequência, dando como resultado uma nova sequência.

exemplo:

> x = 1:5

> sqrt(x)

[1] 1.000000 1.414214 1.732051 2.000000 2.236068

4. Se uma expressão lógica é aplicada a uma sequência, a expressão será aplicada elemento-a-elemento.

exemplo:

> altura>1.70

[1] FALSE TRUE TRUE NA

Componentes de uma Sequência

A forma de se fazer referência a componentes de uma sequência é usando a notação de colchetes "[" e "]". A forma geral é:

nome_da_sequência[índice]

Onde o índice é um número de 1 até o tamanho da sequência. Note que diferentemente de algumas outras linguagens de programação o índice não começa de zero e sim de 1.

Quando o índice é negativo, isso indica que se está REMOVENDO o elemento da sequência, assim a sequência resultante será a sequência original com o(s) elementos(s) de índice negativo removido(s).

Exemplo:

> frutas <- c("pêra","uva","salada mista")

> frutas[2]

[1] "uva"

> frutas[-2]

[1] "pêra" "salada mista"

Um Gráfico Simples ( O Diagrama de Dispersão)

Para se fazer um gráfico de y como função de x, usa-se a função plot(x,y), onde x é a sequência das abcissas e y é a sequência das ordenadas. Essa função abre uma nova janela, ajusta automaticamente as escalas e marca os pontos no plano.

É possível configurar os elementos do gráfico: eixos, escalas, unir ou não os pontos, definir os tipos de marca, definir as cores, e até colocar mais de uma curva em um único gráfico. Mas esses recursos não serão abordados nessa primeira excursão pelo ambiente do R.

Exemplo:

> x <- seq(0, 2*pi, length=100)

> y <- sin(x)

> plot(x,y) # vai aparecer um gráfico da função seno em outra janela.

Função Declaração

O usuário pode extender as funções da linguagem criando suas próprias funções. A sintaxe para a criação da função é:

nome_da_função <- function(arg1, arg2, ..., argn) expressão

Exemplo 1: Uma função que calcula o cubo de um número dado.

> cubo <- function(x) x*x*x

> cubo(2)

[1] 8

Exemplo 2: Uma função que calcula a área de um círculo.

> área.do.círculo <- function(raio) pi*raio^2

> área.do.círculo(3) # Calculando a área de um círculo de raio 3

[1] 28.27433

Exemplo 3: Gráfico de um polinômio criado pelo usuário

> poly <- function(x) (x-2)*(x-1)

> x <- seq(0,3,length=100)

> y <- poly(x)

> plot(x,y)

Argumentos Opcionais

Um ou mais argumentos de uma função podem ser OPCIONAIS, isto é, quando a função for chamada e o valor do argumento não for colocado, um valor padrão será utilizado. Para definir um argumento como opcional, coloca-se o valor padrão na hora que a função é definida.

Exemplo: Uma função que calcula o perímetro de um círculo será criada, se o raio do círculo não for especificado, a função calculará o perímetro de um círculo de raio unitário.

> perimetro.do.círculo <- function(raio=1) 2*pi*raio

> perimetro.do.círculo(3) #Calcula o perímetro de um círculo de raio 3

[1] 18.84956

> perimetro.do.círculo(raio=4) #Calcula o perímetro de um círculo de raio 4

[1] 25.13274

> perimetro.do.círculo() #Com o raio omitido, o 1 será usado

[1] 6.283185

Estruturas de Controle

A função ifelse()

ifelse(condição, valor_se_verdade, valor_se_falso)

Se a condição for verdadeira retorna o segundo argumento, se for falsa retorna o tenceiro argumento.

exemplo:

> x <- 8

> ifelse(x%%2==1,"Impar","Par")

[1] "Par"

O Comando if

if(expressão_lógica) comando_ou_bloco_de_comandos_se_veradeiro else comando_ou_bloco_de_comandos_se_falso

Se a expressão lógica retornar verdadeio o primeiro comando ou bloco de comandos será executado, se for falso o segundo

comando ou bloco de comandos será executado.

Quando há um bloco de comandos, ele deve ser envolvido por chaves para delimitar os comandos.

Exemplo:

> if(fa*fm<0){

+ b <- m

+ } else {

+ a <- m

+ fa <- fm

+ }

O comando for

Executa o comando um número fixo de vêzes. A cada repetição, o contador vale um elemento da sequência. A sintaxe do comando for é:

for( contador in sequência) comando

Exemplo:

Para calcular 1+ 1/2 + 1/3 + .... + 1/10

> S <- 0; for(i in 1:10) S <- S + 1/i

> S

[1] 2.928968

Exemplo:

Dez termos da sequência de Fibonacci.

> a<-1; b<-1

> for(i in 1:10){c<-a+b; a<-b; b<-c;print(c)}

[1] 2

[1] 3

[1] 5

[1] 8

[1] 13

[1] 21

[1] 34

[1] 55

[1] 89

[1] 144

O comando while

while(condição) comando

Repete o comando enquanto a condição for verdadeira.

Exemplo:

> x<-0

> while(x<=10){print(x); x<-x+2}

[1] 0

[1] 2

[1] 4

[1] 6

[1] 8

[1] 10

O comando repeat

repeat comando ou bloco de comandos

Repete o comando ou bloco de comandos indefinidamente.

Abortando um laço for, while ou repeat

Dependendo dos valores das variáveis, um laço pode ser interrompido de duas formas: Ou se sai totalmente da estrutura de controle através do comando break, ou apenas se interrompe aquele laço específico e vai para a próxima repetição, usando o next.

Mais sobre funções

Uma função pode sem mais do que apenas uma expressão matemática para retornar valores numéricos. A expressão da função pode ser substituida por um bloco de comandos que indicam uma sequência de passos a ser executada. A sintaxe extendida de uma função fica:

nome <- function(arg1, arg2, ... ) {

quaisquer comandos da linguagem

valor que vai ser retornado

}

Sempre a última linha executada será o valor a ser retornado pela função. Essa linha é opcional, indicando que a função não retornará nenhum valor.

Executando Arguivos em Lotes (programas)

Várias linhas de comando podem ser colocadas em um arquivo separado no disco e executados, como se fosse um programa. Dessa forma definições de funções e outros procedimentos de rotina não precisam ser digitados toda vez, eles podem ser gravados em um arquivo em disco e executados quando necessário. Para isso:

Usando um editor de texto simples, tipo o bloco de notas, digita-se o programa e ele é gravado normalmente com a extensão .R.

Para executar o arquivo digite o comando:

source("arquivo.R")

Caso se queira que o resultado vá para um outro arquivo em disco digite:

sink("arquivo")

Fatores

Um fator é uma Sequência contendo os valores de uma variável qualitativa. O que distingue um Fator de uma Sequência simples é que o fator tem duas partes:

1) Os dados na forma de uma Sequência de valores do tipo string;

2) uma Sequência composta pelas categorias da variável, chamada "level".

Para se criar um Fator, isto é, transformar uma Sequência em um Fator, usa-se a seguinte sintaxe:

nome_do_fator <-factor(Sequência_de_strings)

Exemplo:

> estado.de.origem <- c("GO","MG","GO","SP","GO","MG","GO","GO")

> estado <- factor(estado.de.origem)

> estado

[1] GO MG GO SP GO MG GO GO

Levels: GO MG SP

A função levels()

Essa função retorna a Sequência das categorias. Mas, mais do que só isso, ela permite que se altere os nomes das categorias, tendo reflexo, inclusive, sobre a Sequência com os dados.

Exemplo:

> estado

[1] GO MG GO SP GO MG GO GO

Levels: GO MG SP

> levels(estado)

[1] "GO" "MG" "SP"

> levels(estado)[1] <- "Goiás" # troca GO por Goiás

> estado

[1] Goiás MG Goiás SP Goiás MG Goiás Goiás

Levels: Goiás MG SP

As Tabelas "Data Frames"

Uma "Data Frame" é uma tabela onde todos os dados estão. Elas são organizadas de tal forma que as diferentes colunas tem nomes, e as linhas são os valores medidos.

Um "data.frame" pode ser criado e editado como uma planilha eletrônica  pelo comando fix(nome.do.data.frame).

Exemplo.

>  dados<-data.frame()

>  fix(dados)

Um "data.frame"  pode ser criado diretamente a partir de um grupo de Sequências, fatores ou listas através da função data.frame(), com a seguinte sintaxe:

nome.da.tabela <- data.frame(nome.da.coluna.1 = Sequência.1, nome.da.coluna.2 = contatenação.2, ...)

Exemplo.

> pesos <- c(82,71,65,50)

> alturas <- c(1.82, 1.71, 1.65, 1.50)

> estado_de_origem <- c("MG","GO","GO","RJ")

> alunos <- data.frame(peso=pesos,altura=alturas,estado=estado_de_origem)

> alunos

 peso altura estado

1 82   1.82    MG

2 71   1.71    GO

3 65   1.65    GO

4 50   1.50    RJ

Nesse caso a tabela "alunos" guarda as informações de quatro pessoas, a primeira pessoa tem 82 de peso, 1,82 de altura e é originário de Minas Gerais (MG). A segunda pessoa pesa 71, etc.

Lendo uma tabela de um arquivo

Normalmente as tabelas são extensas, compostas por dezenas de colunas, e centenas, às vêzes milhares, de linhas. Nesse caso a digitação, ou geração, dos dados é feita por algum outro software, e importado para o ambiente do R na forma de uma tabela. Para ler os dados de um arquivo em disco use a função read.csv2() com a seguinte sintaxe:

nome_da_tabela <- read.csv2("nome_do_arquivo")

Entretanto o arquivo em disco tem que seguir algumas regras:

1. Os dados devem estar em colunas;

2. Cada coluna deverá ter um nome, que deverá estar na primeira linha;

3. Os elementos na mesma linha tem que estar separados por ponto e vírgula (;). Para atender esse requisito ao se usar uma planilha eletrônica do brOffice, salve o arquivo como "Texto .CSV" (Comma Separated Value) e marque a opção "ponto e vírgula" como separador (o padrão do BROffice é a vírgula, e ela pode ser confundida com o separador de casas decimais); e

4. O separador de casas decimais tem que ser a vírgula (que é o padrão das planilhas eletrônicas em português).

5. No Gnumeric vá em "Arquivo/Salvar Como" e em "Tipo de arquivo" selecione "Text (Configurable)" .  Clique em "Salvar".  Aparecerá uma caixa de diálogo, troque o item "Separador" para "Ponto e Vírgula", em seguida clique em "Salvar".

Algumas dessas regras são configuráveis, mas a configuração da importação de dados foge ao objetivo dessa apresentação. No lado da planilha eletrônica, é uma prática boa criar uma folha com o título "Exportar para o R", e manter ela como a planilha ativa na hora de salvar como CSV.

Extraindo dados e editando tabelas

A notação mais simples e direta para fazer referência a uma coluna é usar o "$", na seguinte notação

nome_da_tabela$nome_da_coluna

Com essa representação, o resultado pode ser tratado como uma Sequência, Fator ou Lista normal.

Exemplo:

> alunos$peso

[1] 82 71 65 50

> alunos$estado

[1] MG GO GO RJ

Levels: GO MG RJ

Note que quando a coluna é composta por strings, ela é automaticamente transformada em um Fator pela função data.frame.

> alunos$peso[2]

[1] 71

> levels(alunos$estado)[2]

[1] "MG"

> alunos$peso[2] <- 75 #modificando o segundo peso de 71 para 75

> levels(alunos$estado)[2] <- "Minas" #alterando a categoria MG para Minas

> alunos # ver o resultado

peso altura estado

1 82 1.82 Minas

2 75 1.71 GO

3 65 1.65 GO

4 50 1.50 RJ

A notação [[ ]]

Existe uma notação alternativa ao $, que é mais burocrática, mas que permite que o nome da coluna seja tratado como uma string, ou através do número da coluna, a notação é a que segue

nome_da_tabela[["nome_da_coluna"]]

Exemplo:

> coluna = "altura"

> alunos[[coluna]] # aqui coluna vale "altura"

[1] 1.82 1.71 1.65 1.50

> coluna = "peso"

> alunos[[coluna]] # linha igual à outra, mas coluna vale "peso"

[1] 82 75 65 50

> alunos[[2]]

[1] 1.82 1.71 1.65 1.50

A notação [ ]

Uma coluna pode ser referenciada por seu número usando-se a notação [], como se fosse uma Sequência, inclusive a função length() pode ser usada em uma tabela para determinar o número de colunas. Entretanto existe uma sutileza: o que é retornado através dessa notação é, em si, uma tabela, com uma única coluna.

Exemplo:

> length(alunos) # verifica o número de colunas da tabela.

[1] 3

> pp <- alunos[1]

> pp # essa é uma tabela com uma única coluna chamada "peso"

peso

1 82

2 75

3 65

4 50

> pp$peso # os dados da coluna

[1] 82 75 65 50

Listas (nomeadas)

Uma variável do tipo Lista é uma variável composta por partes, em que cada parte possui um nome. A sintaxe para a criação de uma lista é a que segue:

nome_da_lista <- list(nome1=valor1, nome2=valor2, ... )

A notação para fazer referência aos elementos de uma lista é muito parecido com um data.frame, onde se usa o $, [[]] e [] e length.

Exemplo:

> colaborador <- list(nome="João", cargo="Presidente", carros=c("Fusca","Jipe")) #cria a lista

> colaborador # mostra o que há na variável

$nome

[1] "João"

$cargo

[1] "Presidente"

$carros

[1] "Fusca" "Jipe"

> colaborador$nome # só a parte "nome" da variável

[1] "João"

> colaborador$carros # note que uma Sequência vale

[1] "Fusca" "Jipe"

> length(colaborador) # dá o número de entradas na lista

[1] 3

> colaborador[1] # retorna uma lista com um só elemento

$nome

[1] "João"

> colaborador[[1]] # retorna o primeiro elemento

[1] "João"

> colaborador[["cargo"]] # alternativa a colaborador$cargo

[1] "Presidente"

Matrizes

Para criar uma matriz usa-se a seguinte sintaxe:

nome_da_matriz <- matrix(Sequência, número_de_linhas, número_de_colunas, byrow=TRUE)

Se o argumento opcional byrow for omitido a Sequência será lida por coluna. Se o número de colunas for omitido, será utilizado o número de colunas compatível com os dados.

Exemplos:

> matrix(c(1,2,3,4,5,6),2) # Dados lidos por coluna, e com duas linhas

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

[1,]  1    3    5

[2,]  2    4    6

Note que o número das linhas e das colunas estão indicados entre colchetes.

> matrix(c(1,2,3,4,5,6),3) # Dados lidos por coluna e com três linhas

    [,1] [,2]

[1,]  1    4

[2,]  2    5

[3,]  3    6

> matrix(c(1,2,3,4,5,6),,3) # Dados lidos por coluna e com três colunas (número de linhas omitido)

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

[1,]  1    3    5

[2,]  2    4    6

> matrix(c(1,2,3,4,5,6),,3,byrow=TRUE) # Dados lidos pro linha e com três colunas

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

[1,]  1    2    3

[2,]  4    5    6

Operações com matrizes

As operações aritiméticas feitas com +, -, *, e / são operações elemento-a-elemento. Para operações com matrizes específicas da álgebra linear são definidos outros símbolos e funções:

Exemplos:

> A <- matrix(c(1,2,4,5),2,byrow=TRUE)

> A

    [,1] [,2]

[1,]  1    2

[2,]  4    5

> v <- c(2,1)

> A %*% v # note que o resultado é uma matriz

    [,1]

[1,]  4

[2,]  13

> as.vector(A%*%v) # note que o resultado é uma Sequência

[1] 4 13

> v %*% A

    [,1] [,2]

[1,]  6    9

> solve(A) # inversa da matriz A

          [,1]        [,2]

[1,] -1.666667   0.6666667

[2,]  1.333333  -0.3333333

> solve(A,v)

[1] -2.666667 2.333333

> eigen(A)

$values

[1] 6.4641016 -0.4641016

$vectors

           [,1]       [,2]

[1,] -0.3437238  -0.8068982

[2,] -0.9390708   0.5906905

Operações com Vetores da Álgebra Linear

Além das operações aritiméticas elemento-a-elemento, podem-se realizar as operações com vetores da Física e Álgebra Linear, que são:

O resutado do produto é do tipo matriz, caso se queira transformar o produto interno em escalar, use a função as.vector()

Exemplo:

> x = c(1,2,3)

> y = c(4,5,6)

> x %*% y # note que o resultado é uma matriz 1x1

[,1]

[1,] 32

> x %o% y

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

[1,]  4    5    6

[2,]  8   10   12

[3,] 12   15   18

Próximos tópicos:

Organização da área de trabalho.

Tabelas