Nesta lição abordaremos dois tipos de operadores em linguagem R: Operadores Lógicos e Operadores de Comparação.

Esse operadores trabalham sempre com dois valores de retorno possíveis: TRUE (verdadeiro) ou FALSE (falso), também denotados pelas letras maiúsculas T e F, respectivamente.

Operadores de Comparação em R

Também conhecidos como operadores relacionais, permitem estabelecer a relação entre dois valores de entrada, e retornar um valor lógico verdadeiro ou falso dependendo da relação.

Por exemplo, um operador de comparação pode comparar dois números e dizer se eles são iguais ou não.

Os operadores  de comparação em R são os seguintes:

Os operadores de comparação sempre retornam um valor lógico TRUE ou FALSE.

Operadores Lógicos em R

Também conhecidos como operadores booleanos, permitem trabalhar com múltiplas condições relacionais na mesma expressão, e retornam valores lógicos verdadeiro ou falso.

Os operadores lógicos disponíveis em R são:

Além desses operadores lógicos, também temos disponível em R a função isTRUE(x), que verifica se o valor lógico armazenado na variável x é verdadeiro ou não.

Exemplo de Operadores de Comparação

# Comparando valores numéricos

5 < 8
50 > 100

Podemos armazenar os valores lógicos em variáveis:

resultado <- 4 == 9
print(resultado)

E verificar o tipo da variável:

typeof(resultado)

Exemplos de Operadores Lógicos

# Operador not:

res <- !TRUE
print(res)
res2 <- !(6 != 6)
print(res2)

# Operador or

print(res | res2)

# Operador and

print(res & res2)

# Usando a função isTRUE()

isTRUE(res)

# Operador lógico XOR

xor(res, res2)

É isso aí! Continuaremos a estudar operadores em R na próxima lição. Até!

O post Operadores Lógicos e Operadores de Comparação em R apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Na lição anterior definimos o que é uma matriz em R, quais suas aplicações e como endereçar seus elementos. Agora iremos mostrar como é possível criar matrizes utilizando três funções bastante comuns em linguagem R: matrix(), rbind() e cbind().

Função matrix()

Toma um vetor e o transforma em matriz, dividindo os dados presentes no vetor em várias linhas da matriz.

Sintaxe:

matrix(data = NA, nrow = x, ncol = y, byrow = TRUE | T | F | FALSE)

Onde:

• data é a fonte dos dados (por exemplo, um vetor)
• nrow é o número de linhas desejadas
• ncol é o número de colunas desejadas
• byrow indica se a matriz será preenchida por linhas ou colunas. O padrão é F ou FALSE (por colunas).

Função rbind()

Conecta vetores formando linhas de uma matriz com cada vetor (r = row)

Sintaxe:

rbind(vetor1, vetor2, ..., vetorN)

Função cbind()

Conecta vetores formando colunas de uma matriz com cada vetor (c = column)

Sintaxe:

cbind(vetor1, vetor2, ..., vetorN)

Exemplos

1 – Criar um vetor com a função matrix()

Iniciamos criando um vetor com, digamos, 20 posições preenchidas com números:

> vetor <- 1:20

Agora vamos transformar esse vetor em uma matriz A 4×5 (quatro linhas por cinco colunas) da seguinte forma:

> A <- matrix(vetor, 4, 5)

E então verificamos o conteúdo da matriz criada:

> A

Note os índices indicados para as linhas e colunas da matriz criada.

É importante que o produto do número de linhas pelo número de colunas seja igual ao número total de itens do vetor, para que a matriz possa ser corretamente criada e preenchida. Em nosso caso, 4 linhas x 5 colunas = 20 itens, que é o tamanho do vetor.

E como acessamos o valor armazenado em uma posição da matriz? É simples: basta usar o nome da matriz, seguida de colchetes contendo o número da linha e da coluna separados por vírgulas, nessa ordem. Por exemplo, vamos acessar o elemento que está na linha 3, coluna 4 (número 15):

> A[3,4]
[1] 15

2 – Vamos agora criar uma matriz usando a função rbind()

Começamos criando, por exemplo, três vetores de caracteres, como segue:

> v1 <- c("SP","RJ","MG")
> v2 <- c("RN","MT","AM")
> v3 <- c("PE","RS","SC")

E então criamos uma matriz B unindo os três vetores criados coma função rbind():

> B <- rbind(v1, v2, v3)

E então verificamos o conteúdo da matriz:

> B

Note que são mostrados os nomes dos vetores v1, v2 e v3 nas linhas do vetor criado. Porém, para acessar uma de suas posições, basta referenciá-las normalmente pelos números de linha e coluna, como por exemplo:

> B[3,3]
     v3
[1] "SC"

Também podemos acessar o elemento fornecendo o nome do vetor que originou a linha, em vez do número da linha em si:

> B["v3",3]
      v3
[1] "SC"

3 – E por fim vamos criar uma matriz usando a função cbind().

Primeiramente vamos criar três vetores numéricos, com 6 elementos em cada, como segue:

> n1 <- 1:6
> n2 <- 12:17
> n3 <- 24:29

E então criamos a matriz C unindo os três vetores criados com a função cbind():

> C <- cbind(n1, n2, n3)

Finalmente, verificamos o conteúdo da matriz:

C

Note que os elementos são arranjados em colunas, em vez de linhas, como ocorreu com a função rbind(). E perceba também que, em vez de serem mostrados os números de índice das colunas, são mostrados os nomes dos vetores empregados. Porém, o processo de acesso aos elementos da matriz é o mesmo: basta indicar entre os colchetes os números da linha e da coluna desejados:

C[4,3]
n3
[1] 27

Ou ainda usar o nome da coluna:

C[4,"n3"]
n3
27

É isso aí! Na próxima lição vamos nos aprofundar na manipulação dos elementos de uma matriz, incluindo a atribuição, leitura e alteração dos elementos.

O post Como criar matrizes em R apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Damos o nome de matriz a um vetor bidimensional, composto por linhas e colunas, como uma espécie de tabela. Na verdade, podemos considerar uma matriz como um conjunto de vetores interligados.

As matrizes encontram inúmeras aplicações em computação, principalmente relacionadas às áreas de física, engenharia e análise de dados, que possuem fórmulas que dependem de quantidades multidimensionais e conjuntos de dados de múltiplas dimensões. Um exemplo bem simples de aplicação de matrizes é a construção de jogos de computadores e em computação gráfica, para realizar transformações 2D e 3D, entre inúmeras outras.

Assim como acontece com os vetores em R, somente é possível armazenar dados de um mesmo tipo nas posições de uma matriz. Assim, teremos matrizes de inteiros, ou de caracteres, ou de valores lógicos, mas não matrizes que misturem valores inteiros com caracteres, por exemplo. Além disso, os números de índice tanto das colunas quanto das linhas se inicia em 1, em vez de 0, com acontece em muitas linguagens de programação. Cuidado com esse detalhe!

Abaixo temos um exemplo de uma matriz A com 4 linhas e 4 colunas:

E, logo a seguir, temos a mesma matriz A com alguns dados inseridos em posições diversas:

Indexando os elementos de uma matriz

Para referenciar um elemento dentro de uma matriz, usamos um par de valores de índice, que representam a linha onde o valor se encontra e a coluna, respectivamente. Esses valores são números separados por uma vírgula, e posicionados dentro de colchetes (lembre-se, a posição em um vetor também é representada por um número dentro de colchetes), seguindo o nome da matriz (em nosso exemplo, matriz A). Ou seja:

NomeMatriz[Linha, Coluna]

Desta forma, na matriz mostrada anteriormente temos os valores armazenados nas seguintes posições:

Valor 22: posição A[1,1]
Valor 32: posição A[2,3]
Valor 15: posição A[2,2]
Valor 96: posição A[4,3]

Em R, podemos fazer referência a todos os elementos de uma linha em particular indicando dentro dos colchetes o números dessa linha, seguido por uma vírgula, e sem indicar o número da coluna. Assim, podemos referenciar, por exemplo, a coluna 3 de nossa matriz da seguinte forma:

> A[3,]

Isso permite selecionar todos os dados da linha 3 da matriz. E, de mesma forma, também é possível referenciar todos os valores de uma dada coluna escrevendo dentro dos colchetes uma vírgula, seguida do número da coluna – por exemplo, a coluna 2:

> A[,2]

Assim, teremos todos os dados presentes na coluna 2 da matriz A.

Na próxima lição vamos explorar as possibilidades existentes para a criação de matrizes em R.

O post Matrizes em R apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Já sabemos que os vetores possuem um número de índice que identifica cada valor armazenado em suas posições. Assim, para acessar um elemento qualquer, usamos esse número de índice – por exemplo, para acessar o quarto elemento de um vetor usamos o índice [4].

Porém, em R também é possível atribuir nomes às posições de índice em um vetor, de modo a ser possível acessar esses elementos por meio deste nome escolhido, em vez de utilizar apenas o seu valor numérico. Usar um nome de identificação possui inúmeras utilidades em R, como por exemplo, criar tabelas de lookup.

Um exemplo de vetor nomeado é um dataset (conjunto de dados) interno de nome islands, disponível pronto para uso no R, cuja estrutura pode ser analisada usando-se a função str():

> str(islands)
Named num [1:48] 11506 5500 16988 2968 16 ...
- attr(*, "names") = chr [1:48] "Africa" "Antarctica" "Asia" "Australia" ...

Esse vetor armazena a área da superfície das 48 maiores massas de terra do mundo, incluindo continentes e grandes ilhas. Veja que foi retornada a informação de que se trata de um vetor com 48 elementos, com os valores dos primeiros elementos mostrados.
Na segunda linha, é mostrado que esse vetor possui um atributo que contém a palavra “names“, e os primeiros elementos desse atributo são “Africa”, “Antarctica”, “Asia” e “Australia”. Esses são os nomes de cada posição do vetor, e cada posição também possui o valor armazenado e associado a esses nomes.

Desta forma, podemos acessar os elementos do vetor por nome. Por exemplo, para verificarmos os valores atribuídos às posições “Antarctica” e “Australia”, podemos fazer o seguinte:

> islands[c("Antarctica", "Australia")]
Antarctica Australia
      5500      2968

Para saber quais são os nomes existentes em um vetor nomeado empregados a função names():

> names(islands)
[1] "Africa" "Antactica" "Asia" ...
[6] "Baffin" "Banks" "Borneo" ...

(saída truncada)

Como criar um vetor nomeado em R

Criamos um vetor nomeado atribuindo valores a um vetor comum, e então empregado a função names() para associar os nomes às posições de índice do vetor criado. Vejamos alguns exemplos:

1 – Vamos criar um vetor chamado aulas.materia, no qual iremos armazenar o número de aulas existentes em quatro matérias distintas:

> aulas.materia <- c(8, 10, 8, 12)

Mas de quais matérias são essas quantidades de aulas? Vamos agora associar os nomes das matérias ao vetor, usando-os como nomes das posições de índice:

> names(aulas.materia) <- c("Física", "Português", "História", "Matemática")

Note que passamos um vetor com os nomes das matérias para ser utilizado como nomes das posições. Podemos então verificar o conteúdo do vetor nomeado criado:

> aulas.materia
Física Português História Matemática
     8        10        8         12

2 – Queremos criar um vetor que contenha os nomes dos meses do ano, e os dias que cada mês possui. Para isso, começamos criando um vetor com a quantidade de dias de cada mês, em ordem:

> dias.mês <- c(31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31)

Logo após, vamos atribuir os nomes de índice, que são os nomes dos meses. Podemos criar um vetor contendo esses nomes, com fizemos no exemplo anterior; em inglês é possível utilizar o dataset interno chamado de “month.name”:

> names(dias.mês) <- month.name

Com o vetor criado, podemos consultar a quantidade de dias em um mês qualquer, por exemplo, em maio (“May”):

> dias.mês["May"]
May
31

O mesmo resultado será obtido se passarmos o número de índice da posição (5) em vez no nome atribuído. Para visualizar todos os meses com seus respectivos números de dias fazemos simplesmente:

> dias.mês[month.name]

Podemos também buscar itens neste vetor por meio dos valores armazenados, em vez de usar os índices ou nomes. Por exemplo, para saber quantos meses possuem no máximo 30 dias podemos executar:

> names(dias.mês[dias.mês == 30])
[1] "April" "June" "September"
[4] "November"

Neste exemplo verificamos os valores armazenados no vetor dias.mês comparando seus valores (e não os nomes de índice) com o valor 30, utilizando um operador de comparação de igualdade ==.

Nas próximas lições vamos falar sobre vetores compostos – mais precisamente, sobre matrizes em R.

O post Trabalhando com vetores nomeados em R apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Em R, além das operações aritméticas básicas, também existem diversas funções que podem ser aplicadas diretamente a vetores, para realizar as mais variadas tarefas em conjuntos de dados simultaneamente. Um dos grupos de funções mais importantes são as funções de soma, produto e cumulativas. Nesta lição vamos explorar algumas das principais funções aritméticas que podemos aplicar a vetores em linguagem R.

A tabela a seguir mostra algumas funções aritméticas cujo resultado depende da combinação dos valores presentes em um vetor:

Vejamos exemplos de aplicação dessas funções em vetores. Para isso, empregaremos um vetor x de 15 números, criado conforme a instrução a seguir:

x <- c(13, 24, 2, 45, 34, 33, 10, 8, 32, 39, 16, 19, 9, 25, 42)

Exemplos

1 – Queremos saber o valor dos somatórios dos 15 itens no vetor x:

> res <- sum(x)
> print(res)
[1] 351

2 – Queremos descobrir quais são o maior e o menor valores presentes no vetor:

> min(x)
[1] 2
> max(x)
[1] 45

3 – Suponha que tenhamos um outro vetor, y, com os valores a seguir:

y <- c(4, 7, 9, 12, 11)

Podemos calcular o somatório combinado de ambos os vetores, x e y, usando a mesma função sum(), pois essa função aceita múltiplos vetores como entrada, bastando para isso separá-los por vírgulas:

res <- sum(x, y)
print(res)
[1] 394

4 – Vamos retornar a soma cumulativa dos valores em y – ou seja, o resultado de cada soma parcial realizada:

res <- cumsum(y)
print(res)
[1] 4 11 20 32 43

5 – Retornar o maior valor cumulativo no vetor x:

res <- cummax(x)
print(res)
[1] 13 24 24 45 45 45 45 45 45 45 45 45 45 45 45 

6 – Podemos também retornar as diferenças entre cada valor em u vetor, como por exemplo, no vetor y:

res <- diff(y)
print(res)
[1] 3 2 3 -1

Neste exemplo, foram retornados quatro números:

• 3 é a diferença entre o primeiro e o segundo valores do vetor: 7 -4 
• 2 é a diferença entre o segundo e o terceiro valores do vetor: 9 – 7
• 3 é a diferença entre o terceiro e o quarto valores do vetor: 12 – 9 
• -1 é a diferença entre o quarto e o quinto valores do vetor: 11 – 12 

7 – Também podemos aplicar essas funções a partes de um vetor. Por exemplo, suponha que se deseje saber o somatório apenas dos cinco primeiros valores do vetor x. Para tal, basta indicar entre colchetes as posições desejadas na soma:

sum(x[1:5])
[1] 118

8 – E se quisermos saber qual o valor da soma do elementos  de número 1, 2  e 4 do vetor x? Simples – basta criar um vetor com os números de índice desejados, usando a função combine,  e utilizá-lo na soma:

sum(x[c(1, 2, 4)])
[1] 82

É isso aí! Há muitas outras funções matemáticas que podem ser aplicadas a vetores em R. Vamos estudá-las nas próximas lições.

O post Linguagem R – Funções aritméticas em vetores apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Podemos efetuar operações aritméticas simples com vetores em R de forma rápida e muito fácil. Vamos criar os vetores a e b, numéricos, com os valores a seguir:

> a <- c(3, 6, 9, 12)
> b <- c(2, 4, 6, 8)

Suponha que seja precisemos adicionar os valores desses dois vetores, em forma ordenada – primeiro valor de a somado com o primeiro valor de b, e assim sucessivamente até o ultimo valor. Como fazemos isso em R? Simples – somamos os vetores diretamente:

> a + b
[1] 5 10 15 20

Simples não? Em outras linguagens de programação seria necessário criar um loop, usando alguma estrutura de repetição, e inserir a operação aritmética dentro desse loop, retornando cada valor calculado. Em R basta somar os dois vetores, e todo o cálculo é feito automaticamente.

Aplicamos essa mesma técnica para realizar outras operações básicas, como a subtração (-), multiplicação (*), divisão (/) e exponenciação (^). Veja, por exemplo, o produto entre os valores dos dois vetores:

> a * b
[1] 6 24 54 96

Ou ainda os valores do vetor a elevados aos valores do vetor b:

> a ^ b
[1] 9  1296  531441   429981696

Em todos esses exemplos os vetores possuíam o mesmo comprimento (4 elementos). Mas o que acontece se os vetores envolvidos em um cálculo aritmético tiverem tamanhos diferentes? Vejamos um exemplo – vamos criar o vetor f, contendo 6 elementos:

> f <- c(1, 1, 2, 3, 5, 8)

Vamos tentar somar esse vetor com o vetor b:

> b + f
[1] 3 5 8 11 7 12
Warning message:
In b + f: longer object length is not a multiple of shorter object length.

Todos os valores foram somados. Porém, note que os dois últimos valores obtidos, 7 e 12, corresponde à soma de 5 + 2 e 8 + 4, primeiro e segundo valores de b com os dois últimos valores de f. O que ocorreu é que, como o vetor b é menor que o vetor f, seus valores foram reciclados, ou seja, foram reutilizados quando a última posição do vetor foi utilizada no cálculo. O R nos avisou disso com a mensagem que diz que o comprimento do maior objeto (f) não é um múltiplo do comprimento do menor objeto (b).

A reciclagem sempre ocorre quando os vetores envolvidos não possuem o mesmo comprimento, e a mensagem de aviso aparece quando o maior vetor não tem um comprimento múltiplo do menor vetor – mas, ainda assim, os valores do menor vetor são reciclados até a posição necessária.

Um exemplo bem claro da reciclagem de vetores é a multiplicação de todos os valores de um vetor por um valor fixo. Suponha que os valores do vetor a precisem ser multiplicados por 5 – todos eles multiplicados por esse mesmo valor. Como procedemos? Basta multiplicar o vetor por 5:

> a * 5
[1] 15 30 45 60

Além de podermos aplicar operações aritméticas em e entre vetores, podemos também aplicar diversas funções sobre os valores de um vetor, como por exemplo calcular o somatório de seus valores, visualizar valores acumulados ou ainda a diferença entre cada valor de um vetor.

Veremos algumas dessas funções aritméticas na próxima lição.

O post Aritmética simples com vetores em R apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Uma das características mais poderosas da linguagem R é o fato de que qualquer pessoa pode criar funções e compartilhá-las com outros usuários do R, de forma organizada.
Desta forma, muitas funções estão disponíveis de forma imediata, o que facilita muito o trabalho do analista de dados – desde que ele saiba como encontrar e instalar essas funções.

A maioria das funções é distribuída na forma de pacotes (“packages”), que são constituídos por código em R, arquivos de ajuda, conjuntos de dados (datasets), e outros elementos importantes para o funcionamento das funções.

Os pacotes são, no geral, encontrados em websites especiais denominados “repositórios”. O repositório mais importante do R é o CRAN – Comprehensive R Archive Network – acessível pelo endereço http://cran.r-project.org, e possui centenas de pacotes prontos para serem adicionados à sua instalação do R.

Veremos neste tutorial como gerenciar pacotes em R utilizando comandos do terminal.

Como instalar um pacote em R

Para instalar um pacote em R usamos a função install.packages(). Sua sintaxe é a seguinte:

> install.packages(nome_pacote)

Vamos instalar um pacote de exemplo, de nome “fortunes”:

> install.packages("fortunes")

Veja a saída gerada durante a instalação do pacote:

Instalação de pacotes em linguagem R

Para usar um pacote instalado, é necessário carregá-lo quando for preciso utilizá-lo. Por padrão, o R não carrega automaticamente na memória todos os pacotes que você instala, para poupar memória do sistema.

Veja o que ocorre ao tentarmos utilizar uma função de um pacote que não foi carregado:

> fortune(1)

Para carregar um pacote instalado usamos a função library(). Sua sintaxe é bem simples:

> library("nome_pacote")

Após carregar o pacote, ele estará disponível para uso na linha de comandos e em seus scripts. Vamos carregar o pacote fortunes e tentar uma de suas funções novamente:

> library("fortunes")
> fortune(1)

Descarregando um pacote

Para descarregar um pacote que não esteja mais em uso, para liberar espaço em memória, usamos a função detach(), como segue:

> detach(package:fortunes, unload=TRUE)

A partir desse momento as funções do pacote não estarão mais disponíveis para uso, porém o pacote continua instalado no sistema, e pode ser utilizado novamente a qualquer momento, bastando para isso carregá-lo novamente.

Desinstalar pacotes em R

Para desinstalar um pacote em R usamos a função remove.packages(). Podemos remover uma ou mais funções de uma vez, fornecendo seus nomes separados por vírgulas. Veja sua sintaxe básica:

> remove.packages("pacote_a_remover")

Ou, para remover vários pacotes de uma vez:

> remove.packages(c("pacote1", "pacote2", "...", "pacoteN")

Criamos um vetor contendo os nomes dos pacotes a remover, e o passamos à função como argumento.

Atualizar pacotes em R

Podemos atualizar os pacotes existentes em uma instalação do R usando a função update.packages():

> update.packages()

Podemos também visualizar uma listagem extensa de todos os pacotes do R que estão instalados em seu sistema por meio da função installed.packages():

> installed.packages()

A imagem a seguir mostra o início da saída deste comando (truncada, pois é muito extensa):

Pacotes instalados no R. Saída truncada.

Se você utiliza o IDE RStudio, é possível realizar essas tarefas de gerenciamento de pacotes por meio da interface gráfica, de forma simplificada. Veremos como fazer isso em outro tutorial.

Até!

O post Como instalar e carregar pacotes em R apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Nesta lição vamos introduzir um assunto de muita importância em linguagem R: os Vetores.

Os vetores são uma das características mais importantes em R, uma estrutura de dados amplamente empregada em inúmeros cenários diferentes.

Bem, mas o que é exatamente um vetor?

Um vetor é, basicamente, um conjunto unidimensional de valores, todos do mesmo tipo, que funciona como uma espécie de “variável multivalorada”. Em R, os vetores podem ter quantos valores (elementos) forem necessários – mesmo um único valor é um vetor contendo um elemento.

A figura a seguir ilustra um vetor de nome “Vetor1“, com cinco elementos de índices de 1 a 5, preenchido com valores numéricos inteiros:

Vetor de 5 posições (elementos) preenchido com valores numéricos.

Como criar um vetor em R

Podemos criar vetores em R de várias formas. Por exemplo, é possível criar um vetor de números inteiros simplesmente usando o operador : (“até”). Suponha que você queira criar um vetor que contenha os números de 2 a 8, e batizá-lo como “vetor”. Para isso, basta executar o comando a seguir:

vetor <- 2:8

Isso criará um vetor com as posições de 1 até 7 preenchidas com os valores numéricos inteiros de 2 até 8. Para visualizar seu conteúdo, basta usar uma função como print():

print(vetor)
[1] 2 3 4 5 6 7 8

O número 1 entre colchetes no início da linha ([1]) indica que esta linha inicia com a exibição do elemento 1 do vetor (primeira posição). 

Note que o vetor criado possui os números de 2 até 8, em intervalos de valor 1. Esse intervalo é o padrão, mas podemos especificar um intervalo diferente para os números. Para tal, fazemos uso da função seq(). Suponha um conjunto de números de 2 até 18, porém com um intervalo de valor 2 entre eles. Criamos esse vetor assim:

vetor <- seq(from = 2, to = 18, by = 2)
print(vetor)
[1] 2 4 6 8 10 12 14 16 18

A função seq() requer por padrão três parâmetros: 

• from = valor inicial
• to = valo final
• by = incremento

Alternativamente, podemos fornecer esses parâmetros (em ordem) sem a necessidade de especificá-los por nome:

vetor <- seq(2,18,2)
print(vetor)
[1] 2 4 6 8 10 12 14 16 18

Também é possível especificar o comprimento da sequência de valores a ser criada, usando o argumento opcional length.out. Neste caso, o tamanho do intervalo entre os valores será calculado automaticamente. Por exemplo, suponha que precisamos de uma sequência que contenha 10 valores, entre os números 2 e 8:

vetor <- seq(from = 2, to = 8, length.out = 10)
print(vetor)
[1] 2.00 2.66 3.33 4.00 4.66 5.33 6.00 6.66 7.33 8.00

Note que o intervalo entre os números foi calculado automaticamente, e os 10 valores foram gerados para o vetor. Neste caso é obrigatório especificar os nomes dos parâmetros passados à função.

Combinando vetores em R

É possível combinar um ou mais vetores, criando assim um novo vetor em R por meio da aplicação da função combine, representada por c( ). Com ela, podemos combinar vetores de qualquer tamanho, seja contendo um único elemento ou contendo milhares deles.

Vejamos um exemplo.

vetor1 <- 1:5
vetor2 <- 12:16
vetor3 <- c(vetor1, vetor2)
print(vetor3)
[1] 1 2 3 4 5 12 13 14 15 16

Note que a ordem dos valores é mantida – vetor1 foi passado como parâmetro antes de vetor2 à função, e por isso seus valores são mostrados antes também.

Também usamos a função c() para criar vetores que contenham valores especificados, como por exemplo:

vetor1 <- c("Fábio", "Maria", "Ana", "Bruce")

Repetindo vetores em R

Também podemos repetir os valores presentes em um vetor diversas vezes para criar um vetor de tamanho maior (ou para outro propósito qualquer), de forma simples e rápida com o emprego da função rep() – “replicate“. Podemos utilizar essa função de várias formas, passando alguns parâmetros modificadores a ela. Vejamos alguns exemplos:

1 – Repetir o vetor completo um número determinado de vezes – como por exemplo, 5 vezes:

vetor1 <- 1:5
rep(vetor1, times = 5)
[1] 1 2 3 4 5 1 2 3 4 5 1 2 3 4 5 1 2 3 4 5
[21] 1 2 3 4 5

2 – Podemos repetir cada valor dentro do vetor com o argumento each:

vetor1 <- 1:5
rep(vetor1, each = 3)
[1] 1 1 1 2 2 2 3 3 3 4 4 4 5 5 5

3 – Repetir cada valor um número diferente de vezes. Para isso, passamos um vetor como argumento de times, contendo o número de vezes que cada elemento deverá ser repetido em suas respectivas posições:

vetor1 <- 1:5
rep(vetor1, times = c(1,2,1,2,1))
[1] 1  2 2 3  4 4  5

Neste caso mandamos repetir o primeiro valor de vetor1 uma vez, o segundo valor duas vezes, o terceiro valor, uma vez, o quarto, duas vezes, e o quinto valor, uma vez também.

4 – Repetir os valores de um vetor um número determinado de vezes, de forma individual, até que um tamanho máximo seja alcançado (número de itens), mesmo que a última repetição fique incompleta:

vetor1 <- 1:5
rep(vetor1, length.out = 16)
[1] 1  2 3 4 5 1 2 3 4 5 1 2 3 4 5 1

Pedimos para que a função repetisse os valores de vetor um até obtermos 16 valores – note que na última repetição, somente o valor “1” foi utilizado, pois é o 16º valor.

Testando o tipo de um vetor

Podemos empregar diversas funções para verificar o tipo de dado armazenado em um vetor. São elas:

• is.numeric – Verifica se um vetor é de algum tipo numérico
• is.integer – Verifica se o vetor é do tipo numérico inteiro
• is.double – Verifica se o vetor é do tipo double
• is.complex – Verifica se o vetor é do tipo número complexo
• is.character – Verifica se o vetor é do tipo string de caracteres
• is.logical  – Verifica se o vetor é do tipo booleano

Sem nos esquecermos da função typeof(), que retorna o tipo do objeto armazenado.

Vejamos alguns exemplos.

vetor1 <- 1:10
vetor2 <- c(1+2i, 2+3i, 3+5i)
vetor3 <- c("Fábio", "Monica", "Ana")
is.numeric(vetor1)
[1] TRUE
is.double(vetor1)
[1] FALSE
is.character(vetor2)
[1] FALSE
is.complex(vetor2)
[1] TRUE
is.character(vetor3)
[1] TRUE

Verificando as propriedades de um vetor em R

Podemos verificar a estrutura de um vetor – ou seja, seu tipo e conteúdo – por meio da função str(). Vejamos a estrutura dos vetores criados na seção anterior:

str(vetor1)
int [1:10] 1 2 3 4 5 6 7 8 9 10
str(vetor2)
cplx [1:3] 1+2i 2+3i 3+5i
str(vetor3)
chr [1:3] "Fábio" "Monica" "Ana"

A primeira palavra retornada indica o tipo de dados do vetor (inteiro, complexo e caractere, em nosso exemplos). E os números dentro dos colchetes indicam as dimensões do vetor. Por exemplo, o vetor1 possui uma única dimensão, com os índices especificados pelos números 1:10.

Caso você queria apenas saber o tamanho de um vetor, use a função length():

length(vetor2)
[1] 3

Isso nos diz que o vetor2 possui o tamanho de 3 elementos.

Como acessar os elementos de um vetor

Para que os vetores tenham realmente utilidade é necessário que seja possível acessar seus elementos individuais, para que possam ser lidos e manipulados. A maneira mais simples de fazer isso é especificar o número da posição que queremos acessar entre colchetes. Veja um exemplo:

vetor <- c("Fábio", "Monica", "Ana", "Pedro")
print(vetor[2])
[1] "Monica"

Neste exemplo acessamos a posição de índice 2 do vetor, que nos retornou o segundo valor armazenado – no caso a string “Monica”.

Podemos acessar mais de um elemento combinando seus números de índice:

print(vetor[c(1,3)])
[1] "Fábio" "Ana"

Retornar todos os elementos exceto alguns determinados:

print(vetor[c(-1, -4)])
[1] "Monica" "Ana"

Ou ainda retornar apenas um grupo sequencial de elementos, como por exemplo os três primeiros:

print(vetor[1:3))
[1] "Fábio" "Monica" "Ana"

Alterando o conteúdo de um vetor

Podemos alterar os valores dos elementos de um vetor empregando também os colchetes e números de índice. Veja um exemplo:

vetor <- c("Fábio", "Monica", "Ana", "Pedro")
print(vetor[2])
[1] "Monica"
vetor[2] <- "Sofia"
vetor[2]
[1] "Sofia"

Neste exemplo nós alteramos o elemento da segunda posição do vetor de “Monica” para “Sofia”.

Podemos esvaziar um vetor atribuindo a ele o valor NULL:

vetor <- NULL
vetor
NULL

Note que o vetor continua existindo, apesar de não possuir nenhum elemento. Caso seja necessário destrui-lo em definitivo, desalocando o vetor da memória, use a função rm():

rm(vetor)
vetor
Error: object 'vetor' not found

Aritmética com Vetores

É possível realizar operações aritméticas com os valores contidos em um vetor. Essas operações são efetuadas membro a membro, ou seja, em um elemento por vez.

Vejamos um exemplo. Suponha um vetor de 5 números, de 1 a 5. Queremos multiplicar todos os seus elementos por 2:

vetor <- 1:5
vetor * 2
[1] 2 4 6 8 10

Outro exemplo. Suponha que também temos um outro vetor, vetor2, com os números de 20 a 24, e queremos adicionar o dois vetores:

vetor <- 1:5
vetor2 <- 20:24
vetor + vetor2
[1] 21 23 25 27 29

Veja que o primeiro elemento de vetor foi adicionado ao primeiro elemento de vetor2, e assim por diante.

O mesmo ocorrerá com as outras operações básicas – multiplicação, subtração e divisão.

Reciclagem

Se, ao efetuarmos uma operação aritmética entre dois vetores, um deles tiver tamanho diferente – ou seja, of menor – seus valores serão reciclados (repetidos) durante as operações. Veja o exemplo:

vetor <- 1:5
vetor2 <- 6:8
vetor * vetor2
[1] 6 14 24 24 35
Warning message:
In vetor * vetor2 :
longer object length is not a multiple of shorter object length

Note que foi emitida uma mensagem de aviso, dizendo que o comprimento do vetor maior não é um múltiplo do menor. Os valores obtidos são interpretados assim:

1 x 6 = 6
2 x 7 = 14
3 x 8 = 24
4 x 6 = 24 // Aqui começa a reciclagem de valores do vetor2.
5 x 7 = 35

O post Trabalhando com Vetores em R apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Usamos uma estrutura de desvio condicional para tomar uma decisão de acordo com o resultado de uma condição (teste lógico), e então executar um bloco de códigos que depende do resultado desse teste.

As estruturas de decisão podem ser Simples, Composta ou Encadeada, e são criadas com o emprego da declaração if

Desvio Condicional Simples – if

O desvio condicional simples permite executar um bloco de código caso o resultado do teste seja verdadeiro, ignorando um resultado falso.

x <- 30
if (x == 30) {
  res <- "Número igual a 30"
  print(res)
}

Desvio Condicional composto: if / else

O desvio condicional composto permite criar dois blocos de código após realizar o teste lógico:

Se o teste lógico retornar verdadeiro, as instruções contidas no bloco if serão executadas (como no condicional simples)
Porém, se o teste lógico retornar falso, as instruções contidas em um bloco chamado else é que serão executadas.

x <- 30
if (x == 30) {
  res <- "Número igual a 30"
} else {
    res <- "Número diferente de 30"
  }
print(res)

Note que a instrução else deve estar localizada na mesma linha da chave de fechamento da instrução if, ou o script não funcionará.

Para declarações compostas com apenas uma instrução a executar, é possível abreviar o código da seguinte maneira:

x <- 30
res <- if (x == 30) "Igual" else "Diferente"
print(res)

Desvio Condicional Encadeado: if / else if / else

Em muitas situações é preciso verificar condições de teste sucessivas, onde uma ação será executada se um conjunto anterior de ações for satisfeito.

Podemos usar nestes casos uma estrutura denominada Desvio Condicional Encadeado, que basicamente é o encadeamento (combinação) de estruturas de decisão compostas em um script.

x <- 30
if (x == 30) {
  res <- "Número igual a 30"
} else if (x > 30{
    res <- "Número maior que 30"
  } else {
      res <- "Número menor que 30"
    }
print(res)

Note que nesse caso combinamos as declarações else e if em uma mesma linha, para criar o encadeamento de condicionais.

Próximo: Estruturas de Repetição While e For em linguagem R

O post Condicionais em linguagem R: if / else if / else apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Frequentemente é preciso repetir um trecho de um script diversas vezes. Nesse caso podemos usar uma estrutura de “loop” (ou laço), que permite realizar essa repetição de trechos de código quantas vezes forem necessárias, sem precisar repetir o código em si no script.

Os loops são chamados também de estruturas de repetição. Nesta lição estudaremos dois tipos de estruturas de repetição em R: os laços While e For.

Estrutura de repetição While em R

A estrutura while realiza um teste lógico no início do loop, e cada vez que esse teste retorna o valor verdadeiro, os comandos associados ao laço são executados.

Quando o teste retornar o valor falso, o laço é interrompido e o loop termina.

Sintaxe

while(teste) {
  comandos
}

Exemplo:

x <- 1
while(x <= 10) {
  print(x)
  x <- x + 1
}

Estrutura de repetição For em R

A estrutura de repetição for permite criar loops para casos onde sabemos de antemão o número de repetições que devem ser realizadas.

Por exemplo, se soubermos previamente que o código deve se repetir 10 vezes, podemos usar o laço for.

Sintaxe

for (variável in vetor_números) {
  comandos
}

Exemplo

for (i in 1:10) {
  print(i)
}

Obs.: a estrutura 1:10 representa um vetor de números, contendo os números inteiros de 1 até 10. Podemos visualizar seu conteúdo assim no console:

> (1:10)

Estudaremos os vetores com detalhes em lições posteriores.

Anterior: Decisão Condicional com if / else em R

O post Estruturas de repetição em R – laços while e for apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.