Panorama Geral (1h)
R/RStudio/RPosit
Linguagem R, pacotes, galerias
RPosit Cloud
Elementos Básicos (1h)
Operações matemáticas
Criação de objetos
Operações com objetos
Lógica (1h)
Operações Lógicas com Objetos
Sequências e Loops
Markdown e Quarto (1h)
Apresentação
Elaboração de documentos
Publicação
Recursos gráficos (1h)
Elaboração de Gráficos
Pacote básico
ggplot2
Atividades (3h)
Utilização de funções para elaboração de mandalas
Produção de um mapa geográfico com o pacote leaflet
Introduzir a linguagem R e suas funcionalidades.
Panorama Geral (1h) - Compreender o ambiente de desenvolvimento R/RStudio/RPosit. - Familiarizar-se com a linguagem R, seus pacotes e galerias. - Explorar as funcionalidades do RPosit Cloud.
Elementos Básicos (1h)
Lógica (1h) - Realizar operações lógicas com objetos em R. - Compreender o uso de sequências e loops para controle de fluxo.
Markdown e Quarto (1h) - Criar apresentações usando Markdown. - Elaborar documentos usando RMarkdown. - Aprender a publicar documentos gerados a partir do RMarkdown.
Recursos Gráficos (1h) - Elaborar gráficos básicos em R. - Familiarizar-se com o uso do pacote básico para gráficos. - Explorar o poderoso pacote ggplot2 para criação de gráficos avançados.
Atividades (3h) - Utilizar funções em R para elaborar mandalas de forma interativa. - Produzir um mapa geográfico personalizado usando o pacote leaflet em R.
Cadetes do primeiro ano da Academia da Força Aérea.
Conteúdo a ser abordado:
A linguagem R é uma linguagem de programação amplamente utilizada para análise estatística de dados e produção de gráficos. Existem muitos recursos disponíveis para aprender e aprimorar suas habilidades em R, incluindo livros, sites e tutoriais online. Alguns exemplos de livros e sites que podem ser úteis incluem o livro “Utilizando a Linguagem R” da Alta Books, o site do projeto R e o site do RStudio/Posit.
Além disso, existem muitos exemplos de produção docente que utilizam a linguagem R, como a calculadora amostral criada pela profa. Luciane Alcoforado. Esses exemplos podem fornecer inspiração e orientação para aqueles que desejam usar R em suas próprias pesquisas ou projetos. É importante explorar esses recursos para aprimorar suas habilidades e conhecimentos em R.
<https://www.livrosabertos.sibi.usp.br/portaldelivrosUSP/catalog/book/1017>
<http://www.estatisticacomr.uff.br/?page_id=21>
<https://altabooks.com.br/produto/utilizando-a-linguagem-r/>
<https://www.r-project.org/>
<https://cloud.r-project.org/>
<https://posit.co/products/open-source/rstudio/>
<https://r-graph-gallery.com/>
<https://quarto.org/docs/gallery/>
<https://shiny.posit.co/r/gallery/>https://lucianefalcoforado.shinyapps.io/Teste_Termos/
#Adição:
3 + 2 #resulta em 5[1] 5#Subtração:
3 - 2 #resulta em 1[1] 1#Multiplicação:
3 * 2 #resulta em 6[1] 6#Divisão:
3 / 2 #resulta em 1.5[1] 1.5 #R também suporta operações de potenciação e radiciação:
#Potenciação:
3 ^ 2 #resulta em 9[1] 9#Radiciação:
sqrt(9) #resulta em 3[1] 3A ordem de operações (precedência dos operadores) em R segue a convenção matemática padrão. Primeiro, as operações dentro dos parênteses são realizadas, seguidas pelas operações de potenciação e radiciação. Em seguida, as operações de multiplicação e divisão são realizadas da esquerda para a direita, seguidas pelas operações de adição e subtração, também da esquerda para a direita. Por exemplo:
(3 + 2) * 2 #resulta em 10, porque a adição dentro dos parênteses é realizada primeiro, seguida pela multiplicação.[1] 103 + 2 * 2 #resulta em 7, porque a multiplicação é realizada antes da adição.[1] 7Para começar a manipular vetores e tabelas com R, é importante entender os conceitos básicos de como os dados são armazenados e acessados em R. Vetores são sequências unidimensionais de valores, enquanto tabelas são conjuntos bidimensionais de dados organizados em linhas e colunas. É possível criar vetores e tabelas diretamente no R, ou importá-los de arquivos externos.
Uma vez que os dados estejam armazenados em vetores ou tabelas, é possível acessá-los e modificá-los usando uma variedade de funções e operadores.
- Manipulação de vetores.#Criando um vetor: c()
c(2,3,5)[1] 2 3 5#batizando o vetor:
numeros = c(2,3,5)
letras = c("A", "B", "C", "D")
#exibindo os dados dos vetores
numeros[1] 2 3 5letras[1] "A" "B" "C" "D"#qual o comprimento dos meus vetores?
length(numeros); length(letras)[1] 3[1] 4#qual o valor do vetor numa posição específica (entre colchetes)
numeros[2][1] 3letras[3][1] "C"#obtendo a soma de dois vetores (mesmo tamanho!)
x1=c(4, 10, 20)
x2=c(6, 0, -10)
x1+x2[1] 10 10 10#obtendo o produto de dois vetores
x1*x2[1] 24 0 -200#obtendo o produto escalar de dois vetores
x1%*%x2 [,1]
[1,] -176#obtendo a soma dos elementos de um vetor
sum(x1)[1] 34sum(x2)[1] -4- Manipulação de tabela de dados.#criando uma tabela de dados
data.frame(x1=c(4,5,6), x2=c(7,8,9)) x1 x2
1 4 7
2 5 8
3 6 9#batizando a tabela
tabela=data.frame(texto1=c("linha1","linha2","linha3", "linha4"), x1=c(4,5,6,0), x2=c(7,8,9,1))
#exibindo os dados da tabela
tabela texto1 x1 x2
1 linha1 4 7
2 linha2 5 8
3 linha3 6 9
4 linha4 0 1#exibindo as dimensões da tabela
dim(tabela)[1] 4 3nrow(tabela)[1] 4ncol(tabela)[1] 3#exibindo os nomes das colunas da tabela
colnames(tabela)[1] "texto1" "x1" "x2" #Consultando valores em posições específicas da tabela
tabela[1,3][1] 7tabela[1,] texto1 x1 x2
1 linha1 4 7tabela[,3][1] 7 8 9 1tabela$x1[1] 4 5 6 0#Criando novas colunas na tabela
tabela$x3 = tabela$x1+tabela$x2
tabela$x4 = tabela$x1*tabela$x2
tabela texto1 x1 x2 x3 x4
1 linha1 4 7 11 28
2 linha2 5 8 13 40
3 linha3 6 9 15 54
4 linha4 0 1 1 0Será abordado na disciplina de ESPR.
Crie dois vetores numéricos com 5 posições em cada, atribua um nome a cada um deles e depois junte-os em uma tabela de dados que contenha 3 colunas, as duas primeiras contendo os vetores criados inicialmente e a terceira sendo a soma ao quadrado dos dois vetores.
== (igual a), != (diferente de), >, <, >=, <=, etc.Os operadores lógicos na linguagem R são usados para realizar operações lógicas em valores lógicos (verdadeiro ou falso) ou em expressões que resultam em valores lógicos. Podem ser usados por exemplo para controlar o fluxo de execução de um programa ou para filtrar dados em uma tabela.
tabela=data.frame(sexo=c("feminino","feminino","masculino", "masculino"), idade=c(24,25,26,20), nota=c(7,8,9,10))
tabela sexo idade nota
1 feminino 24 7
2 feminino 25 8
3 masculino 26 9
4 masculino 20 10#Verificar posições que correspondem ao teste lógico
tabela$sexo == "feminino"[1] TRUE TRUE FALSE FALSEtabela$idade != 25[1] TRUE FALSE TRUE TRUE#Selecionar elementos com base no teste lógico
tabela[tabela$sexo == "feminino", ] sexo idade nota
1 feminino 24 7
2 feminino 25 8tabela[tabela$idade >= 25, ] sexo idade nota
2 feminino 25 8
3 masculino 26 9tabela[tabela$sexo == "feminino" & tabela$idade >= 25, ] sexo idade nota
2 feminino 25 8tabela[tabela$sexo == "feminino" | tabela$idade >= 25, ] sexo idade nota
1 feminino 24 7
2 feminino 25 8
3 masculino 26 9tabela[tabela$sexo != "feminino" | tabela$idade >= 25, ] sexo idade nota
2 feminino 25 8
3 masculino 26 9
4 masculino 20 10tabela[tabela$sexo == "feminino" & tabela$idade > 24 & (tabela$nota > 7),] sexo idade nota
2 feminino 25 8for:Looping na programação com R é uma forma de repetir um bloco de código várias vezes, de acordo com uma condição ou um número de iterações. Looping é útil para realizar tarefas que envolvem processamento de dados, cálculos, simulações, entre outras. Existem diferentes tipos de loops em R, como for, while e repeat. Cada um deles tem uma sintaxe e um comportamento específicos.
Um loop for é usado para executar um bloco de código para cada elemento de um vetor ou uma lista. A sintaxe geral é:
for (variavel in sequencia) {
# bloco de código
}Um loop while é usado para executar um bloco de código enquanto uma condição lógica for verdadeira. A sintaxe geral é:
while (condicao) {
# bloco de código
}Um loop repeat é usado para executar um bloco de código indefinidamente, até que uma instrução break seja usada para interromper o loop. A sintaxe geral é:
repeat {
# bloco de código
if (condicao) {
break
}
}Os loops são ferramentas poderosas para automatizar e otimizar tarefas repetitivas em R. No entanto, eles devem ser usados com cuidado, pois podem causar erros ou lentidão se não forem bem projetados ou controlados. Além disso, existem outras formas de realizar operações vetorizadas em R, como as funções apply, sapply, lapply, tapply, entre outras, que podem ser mais eficientes e elegantes do que os loops em alguns casos.
Neste curso vamos mostrar apenas o caso do loop for.
Considere um vetor x. Crie tantos vetores quanto o tamanho do vetor x, denominando-os de x1, x2,…,etc, tal que cada vetor seja formado pelo número correspondente do vetor x em sequência de mesmo comprimento que o vetor x
x=c(5, 3, 9, 10, 11, 3, 9, 12)
# Usar um loop for para iterar sobre cada elemento de x
for (i in seq_along(x)) {
# Criar um vetor com o valor do elemento atual de x repetido length(x) vezes
vetor <- rep(x[i], length(x))
# Atribuir o vetor resultante a uma variável com nome x1, x2, etc.
assign(paste0("x", i), vetor)
# Exibir o vetor resultante
print(vetor)
}[1] 5 5 5 5 5 5 5 5
[1] 3 3 3 3 3 3 3 3
[1] 9 9 9 9 9 9 9 9
[1] 10 10 10 10 10 10 10 10
[1] 11 11 11 11 11 11 11 11
[1] 3 3 3 3 3 3 3 3
[1] 9 9 9 9 9 9 9 9
[1] 12 12 12 12 12 12 12 12Crie um loop para exibir todos os vetores criados.
# Definir o número de vetores criados
n <- length(x)
# Usar um loop for para iterar sobre cada vetor criado
for (i in 1:n) {
# Obter o nome do vetor atual
nome_vetor <- paste0("x", i)
# Obter o valor do vetor atual
valor_vetor <- get(nome_vetor)
# Exibir o nome e o valor do vetor atual
cat(nome_vetor, ": ", valor_vetor, "\n")
}x1 : 5 5 5 5 5 5 5 5
x2 : 3 3 3 3 3 3 3 3
x3 : 9 9 9 9 9 9 9 9
x4 : 10 10 10 10 10 10 10 10
x5 : 11 11 11 11 11 11 11 11
x6 : 3 3 3 3 3 3 3 3
x7 : 9 9 9 9 9 9 9 9
x8 : 12 12 12 12 12 12 12 12 Armazene todos os vetores numa tabela
# Inicializar um dataframe para armazenar os vetores
tabela <- data.frame(x)
n <- length(x)
# Usar um loop for para iterar sobre cada vetor criado
for (i in 1:n) {
# Obter o nome do vetor atual
nome_vetor <- paste0("x", i)
# Obter o valor do vetor atual
valor_vetor <- get(nome_vetor)
# Adicionar o vetor atual ao dataframe
tabela[[nome_vetor]] <- valor_vetor
}
# Exibir o dataframe resultante
tabela x x1 x2 x3 x4 x5 x6 x7 x8
1 5 5 3 9 10 11 3 9 12
2 3 5 3 9 10 11 3 9 12
3 9 5 3 9 10 11 3 9 12
4 10 5 3 9 10 11 3 9 12
5 11 5 3 9 10 11 3 9 12
6 3 5 3 9 10 11 3 9 12
7 9 5 3 9 10 11 3 9 12
8 12 5 3 9 10 11 3 9 12Adapte e teste o código em R que duplica cada arquivo em um diretório, renomeando-o para arquivo1, arquivo2, etc., com a mesma extensão do arquivo original, mantendo também os arquivos originais no diretório:
# Definir o caminho do diretório
diretorio <- "caminho/do/diretorio"
#diretorio <-"C:/Users/TPC02/Documents/AAAA" (endereco para teste da LU)
# Obter os nomes dos arquivos no diretório
arquivos <- list.files(diretorio)
# Usar um loop for para iterar sobre cada arquivo
for (i in seq_along(arquivos)) {
# Obter o nome do arquivo atual
nome_arquivo <- arquivos[i]
# Construir o caminho completo do arquivo atual
caminho_arquivo <- file.path(diretorio, nome_arquivo)
# Obter a extensão do arquivo atual
extensao_arquivo <- tools::file_ext(nome_arquivo)
# Construir o novo nome do arquivo
novo_nome_arquivo <- paste0("arquivo", i, ".", extensao_arquivo)
# Construir o caminho completo do novo arquivo
novo_caminho_arquivo <- file.path(diretorio, novo_nome_arquivo)
# Duplicar o arquivo atual com o novo nome
file.copy(caminho_arquivo, novo_caminho_arquivo)
}Caso deseje excluir os arquivos com nome original basta incluir como último comando dentro do loop: (mas atenção, só faça esse procedimento se tiver certeza da exclusão):
# Remover o arquivo original
file.remove(caminho_arquivo)Utilizamos instruções de controle, como break e next, para modificar o comportamento de loops.
O comando break é útil para interromper um loop quando uma determinada condição é atendida. Neste exemplo, interrompemos o loop quando a soma dos números ultrapassa 10.
# Inicializar uma variável para armazenar a soma dos números
soma <- 0
# Usar um loop for para iterar sobre os números de 1 a 10
for (i in 1:10) {
# Adicionar o valor do elemento atual à variável soma
soma <- soma + i
# Verificar se a soma atual é maior que 10
if (soma > 10) {
# Interromper o loop usando o comando break
break
}
}
# Exibir o resultado final da soma
print(soma)[1] 15O comando next é útil para pular uma iteração de um loop e passar diretamente para a próxima iteração. A seguir, usamos o comando next para pular os números pares e imprimir apenas os números ímpares.
# Usar um loop for para iterar sobre os números de 1 a 10
for (i in 1:10) {
# Verificar se o número atual é par
if (i %% 2 == 0) {
# Redirecionar o loop para a próxima iteração usando o comando next
next
}
# Executar algum código dentro do loop
print(i)
}[1] 1
[1] 3
[1] 5
[1] 7
[1] 9Podemos evitar loops infinitos e garantir que os loops terminem corretamente.
# Inicializar um contador
contador <- 0
# Usar um loop while
while (contador>=0) {
# Incrementar o contador
contador <- contador + 1
# Verificar se o contador atingiu o valor máximo
if (contador > 10) {
# Interromper o loop usando o comando break
break
}
# Executar algum código dentro do loop
print(contador)
}[1] 1
[1] 2
[1] 3
[1] 4
[1] 5
[1] 6
[1] 7
[1] 8
[1] 9
[1] 10Rmarkdown é um formato de documento que permite combinar texto, código e saída em um único arquivo. Arquivos Rmarkdown têm a extensão .Rmd e podem ser convertidos para vários formatos, como HTML, PDF, Word e PowerPoint, usando o pacote R rmarkdown.
Arquivos Rmarkdown são compostos por três partes principais: um cabeçalho YAML que contém metadados e opções para o documento, um ou mais blocos de código que contêm código R a ser executado e exibido, e uma ou mais seções de texto que contêm a narrativa do documento. Arquivos Rmarkdown podem ser editados e renderizados usando o IDE RStudio ou a linha de comando.
Já o Quarto é uma evolução do RMarkdown desenvolvida pela RStudio/Posit, com muitos novos recursos e capacidades. Assim como o RMarkdown, o Quarto usa o Knitr para executar código R e, portanto, é capaz de renderizar a maioria dos arquivos Rmd existentes sem modificações. O Quarto foi desenvolvido para ser multilíngue, começando com R, Python, Javascript e Julia, com a ideia de que funcionará até mesmo para linguagens que ainda não existem. Ao contrário do RMarkdown, o Quarto não tem uma dependência ou requisito para R.
Abra um arquivo quarto a partir da sua janela de trabalho e explore os recursos possíveis que compreendem:
Com o R, é possível criar uma ampla variedade de gráficos personalizados e salvá-los em diversos formatos e resoluções. Existem muitos pacotes gráficos disponíveis no R, incluindo o pacote graphics que vem pré-instalado com o R. Com este pacote, é possível criar e personalizar os principais tipos de gráficos, como gráficos de dispersão, de barras e box-plots.
Muitos destes gráficos serão vistos em detalhe na disciplina de ESPR.
Vamos explorar o tipo mais básico que seria um gráfico no plano cartesiano usando o comando plot().
Exemplo de código em R que cria um gráfico de um polinômio de grau 4 com 4 raízes reais distintas, a saber 1, 2, 3 e 4. A equação do polinômio é \(y=1\cdot x^4 - 10 \cdot x^3 + 35 \cdot x^2 - 50\cdot x + 24\)
# Definir a expressão de y como uma função de x
y <- function(x) {
1* x^4 - 10 * x^3 + 35 * x^2 - 50*x + 24
}
# Definir o intervalo de valores de x para o gráfico
x <- seq(0, 5, length.out = 100)
# Calcular os valores de y para cada valor de x
y_valores <- y(x)
# Criar o gráfico do polinômio
plot(x, y_valores, type = "l", col = "blue", lwd = 2,
main = "Gráfico de um polinômio",
xlab = "x", ylab = "y")
Vamos adicionar uma linha em vermelho em y=0, observando graficamente as raízes do polinômio.
# Definir a expressão de y como uma função de x
y <- function(x) {
1* x^4 - 10 * x^3 + 35 * x^2 - 50*x + 24
}
# Definir o intervalo de valores de x para o gráfico
x <- seq(0, 5, length.out = 100)
# Calcular os valores de y para cada valor de x
y_valores <- y(x)
# Criar o gráfico do polinômio
plot(x, y_valores, type = "l", col = "blue", lwd = 2,
main = "Gráfico de um polinômio",
xlab = "x", ylab = "y")
# Adicionar uma linha vermelha em y=0
abline(h=0, col="red")
Adapte o código acima para o caso de um polinômio de grau 3 com a seguinte equação: \(y=1\cdot x^3 - 8 \cdot x^2 -1\cdot x + 8\)
Considere a variação de x no intervalo -1.1 a 8.1
Seu gráfico deve ficar semelhante a:
Escolha outras funções como o seno, o coseno, o logaritmo, etc para produzir o gráfico.
# Definir o intervalo de valores de x para o gráfico
x <- seq(0, 2*pi, length.out = 100)
# Calcular os valores de y para cada valor de x
y1 <- sin(x)
y2 <- cos(x)
# Dividir a janela gráfica em 2 colunas e 1 linha
par(mfrow = c(1, 2))
# Criar o gráfico do seno
plot(x, y1, type = "l", col = "blue", lwd = 2,
main = "Gráfico do Seno",
xlab = "x", ylab = "y")
# Criar o gráfico do cosseno
plot(x, y2, type = "l", col = "red", lwd = 2,
main = "Gráfico do Cosseno",
xlab = "x", ylab = "y")
Dependendo da situação pode ser interessante sobrepor os dois gráficos, desde que a escala seja a mesma:
# Definir o intervalo de valores de x para o gráfico
x <- seq(0, 2*pi, length.out = 100)
# Calcular os valores de y para cada valor de x
y1 <- sin(x)
y2 <- cos(x)
# Criar o gráfico do seno
plot(x, y1, type = "l", col = "blue", lwd = 2,
main = "Gráficos do Seno e do Cosseno",
xlab = "x", ylab = "y")
# Adicionar o gráfico do cosseno ao gráfico do seno
lines(x, y2, col = "red", lwd = 2)
E podemos juntar 3 gráficos distintos em uma janela dividida em 3 partes:
# Definir o intervalo de valores de x para o gráfico
x <- seq(0, 2*pi, length.out = 100)
# Calcular os valores de y para cada valor de x
y1 <- sin(x)
y2 <- cos(x)
y3 <- 1* x^4 - 10 * x^3 + 35 * x^2 - 50*x + 24
# Dividir a janela gráfica em 3 colunas e 1 linha
par(mfrow = c(1, 3))
# Criar o gráfico do seno
plot(x, y1, type = "l", col = "blue", lwd = 2,
main = "Gráfico do Seno",
xlab = "x", ylab = "y")
# Criar o gráfico do cosseno
plot(x, y2, type = "l", col = "red", lwd = 2,
main = "Gráfico do Cosseno",
xlab = "x", ylab = "y")
# Criar o gráfico do polinômio
plot(x, y3, type = "l", col = "green", lwd = 2,
main = "Gráfico de um polinômio",
xlab = "x", ylab = "y")
Podemos fazer uma anotação no gráfico:
# Criar o gráfico
x <- seq(-1.3, 1.3, length.out = 100)
y <- x^2-1
plot(x, y, type = "l", col = "blue", lwd = 2,
main = "Gráfico de um polinômio",
xlab = "x", ylab = "y")
# Adicionar uma linha vermelha em y=0
abline(h=0, col="red")
# Adicionar uma anotação no ponto (0, -0.7)
text(0, -0.7, "Ponto minimo = (0, -1)", col="magenta")
Podemos também adicionar uma expressão matemática ao gráfico:
# Criar o gráfico
x <- seq(-1.3, 1.3, length.out = 100)
y <- x^2-1
plot(x, y, type = "l", col = "blue", lwd = 2,
main = "Gráfico de um polinômio",
xlab = "x", ylab = "y")
# Adicionar uma linha vermelha em y=0
abline(h=0, col="red")
# Adicionar uma anotação no ponto (0, -0.7)
text(0, -0.7, "Ponto minimo = (0, -1)", col="magenta")
# Adicionar uma expressão matemática ao gráfico
text(0, 0.20, expression(y == x^2 -1), col="orange")
Podemos mudar os limites dos eixos:
# Criar o gráfico
x <- seq(-1.3, 1.3, length.out = 100)
y <- x^2-1
plot(x, y, type = "l", col = "blue", lwd = 2,
main = "Gráfico de um polinômio",
xlab = "x", ylab = "y",
xlim = c(-2, 2), ylim = c(-2, 2))
# Adicionar uma linha vermelha em y=0
abline(h=0, col="red")
# Adicionar uma anotação no ponto (0, -0.7)
text(0, -0.7, "Ponto minimo = (0, -1)", col="magenta")
# Adicionar uma expressão matemática ao gráfico
text(0, 0.20, expression(y == x^2 -1), col="orange")
# Criar o gráfico
x <- seq(-1.3, 1.3, length.out = 100)
y <- x^2-1
plot(x, y, type = "l", col = "blue", lwd = 2,
main = "Gráfico de um polinômio",
xlab = "Eixo X", ylab = "Eixo Y",
xlim = c(-2, 2), ylim = c(-2, 2))
# Adicionar uma linha vermelha em y=0
abline(h=0, col="red")
# Adicionar uma anotação no ponto (0, -0.7)
text(0, -0.7, "Ponto minimo = (0, -1)", col="magenta")
# Adicionar uma expressão matemática ao gráfico
text(0, 0.20, expression(y == x^2 -1), col="orange")
# Adicionar uma legenda ao gráfico
legend("topleft", legend = c("Polinômio", "Reta horizontal"),
col = c("blue", "red"), lty = 1)
O pacote ggplot2 e o pacote graphics são ambos usados para criar gráficos em R, mas eles têm algumas diferenças importantes. O ggplot2 é um pacote que implementa uma “gramática de gráficos”. A ideia básica é que você pode dividir um gráfico em objetos gráficos - dados, escala, sistema de coordenadas e anotação - e pensar neles separadamente. Quando você junta tudo, obtém um gráfico completo.
# Instalar e carregar o pacote ggplot2
#install.packages("ggplot2")
library(ggplot2)
# Definir a expressão de y como uma função de x
y <- function(x) {
1* x^4 - 10 * x^3 + 35 * x^2 - 50*x + 24
}
# Definir o intervalo de valores de x para o gráfico
x <- seq(0, 5, length.out = 100)
# Calcular os valores de y para cada valor de x
y_valores <- y(x)
# Criar um data frame com os valores de x e y
dados <- data.frame(x, y_valores)
# Criar o gráfico do polinômio usando ggplot2
ggplot(dados, aes(x, y_valores)) +
geom_line(col = "blue", size = 1) +
ggtitle("Gráfico de um polinômio") +
xlab("x") + ylab("y")Warning: Using `size` aesthetic for lines was deprecated in ggplot2 3.4.0.
ℹ Please use `linewidth` instead.
# Instalar e carregar os pacotes ggplot2 e gridExtra
#install.packages("ggplot2")
library(ggplot2)
#install.packages("gridExtra")
library(gridExtra)Warning: package 'gridExtra' was built under R version 4.3.1# Definir o intervalo de valores de x para o gráfico
x <- seq(0, 2*pi, length.out = 100)
# Calcular os valores de y para cada valor de x
y1 <- sin(x)
y2 <- cos(x)
# Criar um data frame com os valores de x, y1 e y2
dados <- data.frame(x, y1, y2)
# Criar o gráfico do seno como um objeto ggplot
grafico_seno <- ggplot(dados, aes(x, y1)) +
geom_line(col = "blue", size = 1) +
ggtitle("Gráfico do Seno") +
xlab("x") + ylab("y")
# Criar o gráfico do cosseno como um objeto ggplot
grafico_cosseno <- ggplot(dados, aes(x, y2)) +
geom_line(col = "red", size = 1) +
ggtitle("Gráfico do Cosseno") +
xlab("x") + ylab("y")
# Combinar os dois gráficos em uma única janela usando grid.arrange
grid.arrange(grafico_seno, grafico_cosseno, ncol = 2)
Dependendo da situação pode ser interessante sobrepor os dois gráficos, desde que a escala seja a mesma:
# Instalar e carregar o pacote ggplot2
#install.packages("ggplot2")
library(ggplot2)
# Definir o intervalo de valores de x para o gráfico
x <- seq(0, 2*pi, length.out = 100)
# Calcular os valores de y para cada valor de x
y1 <- sin(x)
y2 <- cos(x)
# Criar um data frame com os valores de x, y1 e y2
dados <- data.frame(x, y1, y2)
# Criar um único gráfico com duas camadas de linhas
ggplot(dados) +
geom_line(aes(x, y1), col = "blue", size = 1) +
geom_line(aes(x, y2), col = "red", size = 1) +
ggtitle("Gráficos do Seno e do Cosseno") +
xlab("x") + ylab("y")
E podemos juntar 3 gráficos distintos em uma janela dividida em 3 partes:
# Instalar e carregar os pacotes ggplot2 e gridExtra
#install.packages("ggplot2")
library(ggplot2)
#install.packages("gridExtra")
library(gridExtra)
# Definir o intervalo de valores de x para o gráfico
x <- seq(0, 2*pi, length.out = 100)
# Calcular os valores de y para cada valor de x
y1 <- sin(x)
y2 <- cos(x)
y3 <- 1* x^4 - 10 * x^3 + 35 * x^2 - 50*x + 24
# Criar um data frame com os valores de x, y1, y2 e y3
dados <- data.frame(x, y1, y2, y3)
# Criar o gráfico do seno como um objeto ggplot
grafico_seno <- ggplot(dados, aes(x, y1)) +
geom_line(col = "blue", size = 1) +
ggtitle("Gráfico do Seno") +
xlab("x") + ylab("y")
# Criar o gráfico do cosseno como um objeto ggplot
grafico_cosseno <- ggplot(dados, aes(x, y2)) +
geom_line(col = "red", size = 1) +
ggtitle("Gráfico do Cosseno") +
xlab("x") + ylab("y")
# Criar o gráfico do polinômio como um objeto ggplot
grafico_polinomio <- ggplot(dados, aes(x, y3)) +
geom_line(col = "green", size = 1) +
ggtitle("Gráfico de um polinômio") +
xlab("x") + ylab("y")
# Combinar os três gráficos em uma única janela usando grid.arrange
grid.arrange(grafico_seno, grafico_cosseno, grafico_polinomio, ncol = 3)
Podemos fazer uma anotação no gráfico:
# Instalar e carregar o pacote ggplot2
#install.packages("ggplot2")
library(ggplot2)
# Criar o gráfico
x <- seq(-1.3, 1.3, length.out = 100)
y <- x^2-1
# Criar um data frame com os valores de x e y
dados <- data.frame(x, y)
# Criar o gráfico do polinômio usando ggplot2
grafico <- ggplot(dados, aes(x, y)) +
geom_line(col = "blue", size = 1) +
ggtitle("Gráfico de um polinômio") +
xlab("x") + ylab("y") +
geom_hline(yintercept = 0, col = "red") +
annotate("text", x = 0, y = -0.7, label = "Ponto minimo = (0, -1)", col = "magenta")
print(grafico)
Podemos também adicionar uma expressão matemática ao gráfico:
# Instalar e carregar o pacote ggplot2
#install.packages("ggplot2")
library(ggplot2)
# Criar o gráfico
x <- seq(-1.3, 1.3, length.out = 100)
y <- x^2-1
# Criar um data frame com os valores de x e y
dados <- data.frame(x, y)
# Criar o gráfico do polinômio usando ggplot2
grafico <- ggplot(dados, aes(x, y)) +
geom_line(col = "blue", size = 1) +
ggtitle("Gráfico de um polinômio") +
xlab("x") + ylab("y") +
geom_hline(yintercept = 0, col = "red") +
annotate("text", x = 0, y = -0.7, label = "Ponto minimo = (0, -1)", col = "magenta") +
annotate("text", x = 0, y = 0.2, label = expression(y = x^2 -1), col = "orange")
print(grafico)Warning in is.na(x): is.na() aplicado a um objeto diferente de lista ou vetor
de tipo 'expression'
Podemos mudar os limites dos eixos:
# Instalar e carregar o pacote ggplot2
#install.packages("ggplot2")
library(ggplot2)
# Criar o gráfico
x <- seq(-1.3, 1.3, length.out = 100)
y <- x^2-1
# Criar um data frame com os valores de x e y
dados <- data.frame(x, y)
# Criar o gráfico do polinômio usando ggplot2
grafico <- ggplot(dados, aes(x, y)) +
geom_line(col = "blue", size = 1) +
ggtitle("Gráfico de um polinômio") +
xlab("x") + ylab("y") +
xlim(-2, 2) + ylim(-2, 2) +
geom_hline(yintercept = 0, col = "red") +
annotate("text", x = 0, y = -0.7, label = "Ponto minimo = (0, -1)", col = "magenta") +
annotate("text", x = 0, y = 0.20, label = expression(y == x^2 -1), col="orange")
print(grafico)Warning in is.na(x): is.na() aplicado a um objeto diferente de lista ou vetor
de tipo 'expression'
# Instalar e carregar o pacote ggplot2
#install.packages("ggplot2")
library(ggplot2)
# Criar o gráfico
x <- seq(-1.3, 1.3, length.out = 100)
y <- x^2-1
# Criar um data frame com os valores de x e y
dados <- data.frame(x, y)
# Criar o gráfico do polinômio usando ggplot2
grafico <- ggplot(dados, aes(x, y)) +
geom_line(col = "blue", size = 1) +
ggtitle("Gráfico de um polinômio") +
xlab("Eixo X") + ylab("Eixo Y") +
xlim(-2, 2) + ylim(-2, 2) +
geom_hline(yintercept = 0, col = "red") +
annotate("text", x = 0, y = -0.7, label = "Ponto minimo = (0, -1)", col = "magenta") +
annotate("text", x = 0, y = 0.20, label = expression(y == x^2 -1), col="orange") +
theme(legend.position="topleft") +
scale_color_manual(name="", values=c("blue", "red"), labels=c("Polinômio", "Reta horizontal"))
print(grafico)Warning in is.na(x): is.na() aplicado a um objeto diferente de lista ou vetor
de tipo 'expression'
- Apresentação do pacote ggplot2 e seus princípios de gramática de gráficos.ggplot() para iniciar a criação de um gráfico.Vamos utilizar o pacote MandalaR para criar mandalas personalizadas.
Observe o exemplo e proponha algumas mudanças nos parâmetros para obter um desenho personalizado.
# Instalar e carregar o pacote MandalaR
#install.packages("MandalaR")
library(MandalaR)Warning: package 'MandalaR' was built under R version 4.3.1# Definir os parâmetros da curva elipse
theta <- c(0, 2*pi)
a <- 1 #parametro da elipse
b <- 2 #parametro da elipse
k <- 40 #angulo de rotação
n <- 500 #numero de pontos (qualidade do grafico)
# Criar um data frame com os pontos da curva elipse
dados_elipse <- pelipse(theta, a, b, k, n)
# Criar a mandala com a curva elipse
plot_mandala(dados_elipse)
Algumas opções possíveis: pastroide, pcardioide, pcircle, pdeltoide, pelipse, pespiral1, pespiral2, plemniscata, plimacon.
# Instalar e carregar o pacote MandalaR
#install.packages("MandalaR")
library(MandalaR)
# Definir os parâmetros da curva espiral1
theta <- c(0, 2*pi)
raio <- 1 #parametro da elipse
k <- 45 #angulo de rotação
n <- 200 #numero de pontos (qualidade do grafico)
# Criar um data frame com os pontos da curva elipse
dados <- pastroide(theta, raio, k, n)
# Criar a mandala com a curva elipse
plot_mandala(dados)
Ou de forma equivalente, chamando pelo nome da curva e definindo os parâmetros.
mandalar_basic(curve="astroide", theta=c(0,2*pi), k=45, n=200, raio=1)
Para produzir mandalas coloridas, consulte a referência em https://www.livrosabertos.sibi.usp.br/portaldelivrosUSP/catalog/view/1017/929/3428, apresente o seu resultado, publicando-o no Rpubs.
ALCOFORADO, L.F. Utilizando a Linguagem R: conceitos, manipulação, visualização, Modelagem e Elaboração de Relatório, Alta Books, Rio de Janeiro. 2021.
__________ MandalaR:Building Mandalas from Parametric Equations of Classical Curves. R package version 0.1.0, https://CRAN.R-project.org/package=MandalaR. 2022
ALCOFORADO, L. F., SANTOS, J. P. M., LIMA, M. V. A., FIRMIANO, A., and LINARES, J. López. Mandalas, Curvas Clássicas e Visualização Com R. Vol. 1. 1st Series. Portal de Livros Abertos da USP. https://www.livrosabertos.sibi.usp.br/portaldelivrosUSP/catalog/view/1017/929/3428. 2023
R CORE TEAM. R: A Language and Environment for Statistical Computing. R Foundation for Statistical Computing, Vienna, Austria. https://www.R-project.org/.2023.
WICKHAM,H. ggplot2: Elegant Graphics for Data Analysis. Springer-Verlag New York, 2016.
WICKHAM, H., ÇETINKAYA-RUNDEL, M., GROLEMUND, G. R for Data Science. (2ª ed.). CRC Press. https://r4ds.hadley.nz/ 2023.