library(ggplot2)
library(base64enc)
library(IRdisplay)

# Criar dataframe
df <- data.frame(X = factor(c(0, 1, 2)), P = c(0.2, 0.5, 0.3))

# Caminho temporário
img_path <- tempfile(fileext = ".png")

# Criar gráfico
p <- ggplot(df, aes(x = X, y = P)) +
  geom_bar(stat = "identity", fill = "steelblue") +
  labs(title = "Distribuição de Probabilidade de X",
       x = "Pacotes por segundo (X)", y = "P(X = x)") +
  ylim(0, 1) +
  theme_minimal()

# Salvar com tamanho reduzido
ggsave(filename = img_path, plot = p, width = 4, height = 1.5, dpi = 150)


# Codificar como base64
img_b64 <- dataURI(file = img_path, mime = "image/png")

# Exibir no notebook (centralizado)
display_html(sprintf('
<div style="text-align:center; max-width: 100%%;">
  <img src="%s" style="max-width: 100%%; height: auto;">
  <div style="margin-top:8px; font-size:90%%; color:#555; text-align:justify;">
    <b>Figura:</b> esta distribuição de probabilidade discreta representa a variável aleatória X, 
    que assume os valores 0, 1 e 2 pacotes por segundo. 
    A altura de cada barra indica a probabilidade P(X = x) de ocorrência de cada valor.
    Observa-se que o valor mais provável é X = 1 (50%%), seguido de X = 2 (30%%) e X = 0 (20%%). 
    Esse tipo de visualização ajuda a compreender a concentração de probabilidade e a assimetria de uma distribuição discreta.
  </div>
</div>
', img_b64))

library(ggplot2)
library(IRdisplay)

# Criar dataframe
df <- data.frame(X = factor(c(0, 1, 2, 3, 4)), P = c(0.0, 0.1, 0.2, 0.3, 0.4))

# img_path para salvar o gráfico
img_path <- "D:/g_drive/docencia/uff/disciplinas/posgrad/vis_rep_data/jupiter/figs/probabilidade_X.png"

# Criar o gráfico
p <- ggplot(df, aes(x = X, y = P)) +
  geom_bar(stat = "identity", fill = "steelblue") +
  labs(title = "Distribuição de Probabilidade de X",
       x = "Pacotes por segundo (X)", y = "P(X = x)") +
  ylim(0, 1) +
  theme_minimal()
# Salvar no diretório
ggsave(filename = img_path, plot = p, width = 7, height = 5, dpi = 300)

# Converter para base64
img_b64 <- dataURI(file = img_path, mime = "image/png")

# Exibir centralizado no notebook
display_html(sprintf('
<div style="text-align:center; max-width: 100%%;">
  <img src="%s" style="max-width: 100%%; height: auto;">
  <div style="margin-top:8px; font-size:90%%; color:#555; text-align:justify;">
    <b>Figura:</b> a distribuição apresentada mostra a probabilidade de X assumir valores entre 0 e 4 pacotes por segundo. 
    Nota-se que a probabilidade cresce de forma contínua até atingir seu valor máximo em X = 4 (40%%), 
    indicando que valores maiores de X são mais prováveis nesta configuração. 
    A visualização permite comparar rapidamente a frequência relativa de cada valor possível.
  </div>
</div>
', img_b64))

library(IRdisplay)
library(base64enc)

# Caminho temporário
img_path <- tempfile(fileext = ".png")

# Valores possíveis da variável Z
z <- c(0, 1)

# Probabilidades genéricas (valores arbitrários apenas para o desenho)
p_val <- 0.7
probs <- c(1 - p_val, p_val)

# Abrir dispositivo gráfico
png(filename = img_path, width = 600, height = 400)

# Criar gráfico de barras
barplot(probs, names.arg = z, col = "steelblue",
        main = "Distribuição de Probabilidade de Z ~ Bernoulli(p)",
        xlab = "Z", ylab = "P(Z = z)",
        ylim = c(0, 1))

# Adicionar rótulos simbólicos
text(x = 1, y = probs[1] + 0.05, labels = expression(1 - p), cex = 1.2)
text(x = 2, y = probs[2] + 0.05, labels = expression(p), cex = 1.2)

dev.off()

# Converter para base64
img_b64 <- dataURI(file = img_path, mime = "image/png")

# Exibir centralizado com descrição
display_html(sprintf('
<div style="text-align:center; max-width: 100%%;">
  <img src="%s" style="max-width: 100%%; height: auto;">
  <div style="margin-top:8px; font-size:90%%; color:#555; text-align:justify;">
    <b>Figura:</b> representação gráfica da distribuição de Bernoulli para a variável Z, 
    onde $P(Z=1) = p$ e $P(Z=0) = 1 - p$. Essa forma de visualização é útil para compreender 
    a natureza dicotômica do experimento, no qual o pacote pode ser aceito ou descartado.
  </div>
</div>
', img_b64))

# Pacotes necessários
library(IRdisplay)

# Criar diretório, se necessário
dir.create("D:/g_drive/docencia/uff/disciplinas/posgrad/vis_rep_data/jupiter/figs/", recursive = TRUE, showWarnings = FALSE)

# img_path do arquivo
img_path <- "D:/g_drive/docencia/uff/disciplinas/posgrad/vis_rep_data/jupiter/figs/enlaces_ativos.png"

# Abrir dispositivo gráfico para salvar
png(filename = img_path, width = 700, height = 500)

# Valores possíveis da variável Z
z <- c(0, 1, 2, 3)

# Probabilidades associadas
p <- c(1/8, 3/8, 3/8, 1/8)

# Gráfico de barras
barplot(p, names.arg = z, col = "steelblue",
        main = "Distribuição de Probabilidade do Número de Enlaces Ativos",
        xlab = "Z", ylab = "P(Z = z)",
        ylim = c(0, 1))

# Fechar dispositivo gráfico
invisible(dev.off())

# Converter para base64
img_b64 <- dataURI(file = img_path, mime = "image/png")

# Exibir centralizado no notebook
display_html(sprintf('
<div style="text-align:center; max-width: 100%%;">
  <img src="%s" style="max-width: 100%%; height: auto;">
  <div style="margin-top:8px; font-size:90%%; color:#555; text-align:justify;">
    <b>Figura:</b> distribuição de probabilidade do número de enlaces ativos, 
    onde a variável aleatória $Z$ representa a contagem de enlaces simultaneamente em operação. 
    A simetria na distribuição indica que configurações com dois enlaces ativos e 
    configurações com apenas um ou três enlaces ativos possuem probabilidades iguais (3/8), 
    enquanto os extremos (nenhum ou todos ativos) têm menor probabilidade (1/8). 
    
  </div>
</div>
', img_b64))

# Pacotes
library(IRdisplay)

# Criar diretório, se necessário
dir.create("D:/g_drive/docencia/uff/disciplinas/posgrad/vis_rep_data/jupiter/figs", recursive = TRUE, showWarnings = FALSE)

# img_path do arquivo
img_path <- "D:/g_drive/docencia/uff/disciplinas/posgrad/vis_rep_data/jupiter/figs/binomial_n4_p08.png"

# Valores de k e parâmetros da binomial
k <- 0:4
n <- 4
p <- 0.8
y <- dbinom(k, size = n, prob = p)

# Salvar gráfico
png(filename = img_path, width = 700, height = 500)
barplot(y, names.arg = k, col = "steelblue",
        main = "Distribuição Binomial (n = 4, p = 0.8)",
        xlab = "Número de sucessos (k)", ylab = "P(X = k)",
        ylim = c(0, 0.5))
invisible(dev.off())

# Converter para base64
img_b64 <- dataURI(file = img_path, mime = "image/png")

# Exibir centralizado no notebook
display_html(sprintf('
<div style="text-align:center; max-width: 100%%;">
  <img src="%s" style="max-width: 100%%; height: auto;">
  <div style="margin-top:8px; font-size:90%%; color:#555; text-align:justify;">
    <b>Figura:</b> distribuição binomial com parâmetros $n = 4$ e $p = 0.8$. 
    A variável aleatória $X$ representa o número de sucessos em quatro tentativas independentes, 
    cada uma com probabilidade $p$ de sucesso. 
    A maior probabilidade ocorre em $k = 4$ sucessos e a menor em $k = 0$, 
    o que indica predominância de resultados com alto número de sucessos.
  </div>
</div>
', img_b64))

# Pacotes
library(IRdisplay)

# Criar diretório, se necessário
dir.create("D:/g_drive/docencia/uff/disciplinas/posgrad/vis_rep_data/jupiter/figs", recursive = TRUE, showWarnings = FALSE)

# img_path do arquivo
img_path <- "D:/g_drive/docencia/uff/disciplinas/posgrad/vis_rep_data/jupiter/figs/tentativas_maliciosas.png"

# Valores da variável Z e probabilidades
z <- c(0, 1, 2, 3)
p <- c(0.1, 0.3, 0.4, 0.2)

# Salvar gráfico
png(filename = img_path, width = 700, height = 500)
barplot(p, names.arg = z, col = "steelblue",
        main = "Distribuição de Probabilidade Tentativas Maliciosas",
        xlab = "Z", ylab = "P(Z = z)",
        ylim = c(0, 0.5))
invisible(dev.off())

# Converter para base64
img_b64 <- dataURI(file = img_path, mime = "image/png")

# Exibir centralizado no notebook
display_html(sprintf('
<div style="text-align:center; max-width: 100%%;">
  <img src="%s" style="max-width: 100%%; height: auto;">
  <div style="margin-top:8px; font-size:90%%; color:#555; text-align:justify;">
    <b>Figura:</b> distribuição de probabilidade da variável $Z$, que representa o número de tentativas maliciosas observadas em um intervalo. 
    A maior probabilidade ocorre em $Z = 2$, seguida de $Z = 1$ e $Z = 3$. 
    O menor valor é observado em $Z = 0$, indicando que o cenário mais comum envolve múltiplas tentativas maliciosas.
  </div>
</div>
', img_b64))

# Pacotes
library(IRdisplay)

# Criar diretório, se necessário
dir.create("D:/g_drive/docencia/uff/disciplinas/posgrad/vis_rep_data/jupiter/figs", recursive = TRUE, showWarnings = FALSE)

# img_path do arquivo
img_path <- "D:/g_drive/docencia/uff/disciplinas/posgrad/vis_rep_data/jupiter/figs/vies_pacotes_baixos.png"

# Valores e probabilidades
k <- 0:5
p <- c(0.30, 0.25, 0.20, 0.15, 0.06, 0.04)

# Salvar imagem
png(filename = img_path, width = 700, height = 500)
barplot(p, names.arg = k, col = "steelblue",
        main = "Distribuição com viés para pacotes baixos",
        xlab = "Número de pacotes por segundo (k)",
        ylab = "P(X = k)",
        ylim = c(0, 0.35))
invisible(dev.off())

# Exibir centralizado no notebook
# Converter para base64
img_b64 <- dataURI(file = img_path, mime = "image/png")

# Exibir centralizado no notebook
display_html(sprintf('
<div style="text-align:center; max-width: 100%%;">
  <img src="%s" style="max-width: 100%%; height: auto;">
  <div style="margin-top:8px; font-size:90%%; color:#555; text-align:justify;">
    <b>Figura:</b> distribuição de probabilidade da variável $X$, que representa o número de pacotes por segundo. 
    As maiores probabilidades estão associadas aos menores valores de $k$, com destaque para $k = 0$, 
    indicando um viés na ocorrência de pacotes baixos.
  </div>
</div>
', img_b64))

# Pacotes
library(IRdisplay)

# Criar diretório se necessário
dir.create("D:/g_drive/docencia/uff/disciplinas/posgrad/vis_rep_data/jupiter/figs", recursive = TRUE, showWarnings = FALSE)

# img_path do arquivo
img_path <- "D:/g_drive/docencia/uff/disciplinas/posgrad/vis_rep_data/jupiter/figs/binomial_falhas_enlaces.png"

# Parâmetros da binomial
n <- 4
p <- 0.2
k <- 0:n
prob <- dbinom(k, size = n, prob = p)

# Salvar gráfico
png(filename = img_path, width = 700, height = 500)
barplot(prob,
        names.arg = k,
        col = "steelblue",
        main = "Distribuição Binomial B(4, 0.2)",
        xlab = "Número de falhas (X)",
        ylab = "P(X = k)",
        ylim = c(0, max(prob) + 0.1))
invisible(dev.off())

# Converter para base64
img_b64 <- dataURI(file = img_path, mime = "image/png")

# Exibir centralizado no notebook
display_html(sprintf('
<div style="text-align:center; max-width: 100%%;">
  <img src="%s" style="max-width: 100%%; height: auto;">
  <div style="margin-top:8px; font-size:90%%; color:#555; text-align:justify;">
    <b>Figura:</b> distribuição binomial $B(4, 0.2)$ da variável aleatória $X$, que representa o número de falhas em quatro enlaces. 
    A maior probabilidade ocorre em $k = 1$, seguida de $k = 0$ e $k = 2$, mostrando que eventos com poucas falhas são mais prováveis.
  </div>
</div>
', img_b64))

# Criar e salvar os dois gráficos lado a lado no diretório atual (para exibição no notebook)
png("binomial_p0_p1.png", width = 800, height = 400)
par(mfrow = c(1, 2))

# Valores
k <- 0:4
n <- 4

p1 <- dbinom(k, size = n, prob = 0.01)
p2 <- dbinom(k, size = n, prob = 0.99)

barplot(p1, names.arg = k, col = "tomato",
        main = "p -> 0", xlab = "X", ylab = "P(X=k)", ylim = c(0,1))

barplot(p2, names.arg = k, col = "steelblue",
        main = "p -> 1", xlab = "X", ylab = "P(X=k)", ylim = c(0,1))
invisible(dev.off())

# Copiar a figura para o diretório externo
invisible(file.copy("binomial_p0_p1.png",
          to = "D:/g_drive/docencia/uff/disciplinas/posgrad/vis_rep_data/jupiter/figs/binomial_p0_p1.png",
          overwrite = TRUE))

# Ajustar o caminho para a imagem gerada
img_path <- "D:/g_drive/docencia/uff/disciplinas/posgrad/vis_rep_data/jupiter/figs/binomial_p0_p1.png"

# Converter para base64
img_b64 <- dataURI(file = img_path, mime = "image/png")

# Exibir centralizado no notebook com legenda
display_html(sprintf('
<div style="text-align:center; max-width: 100%%;">
  <img src="%s" style="max-width: 100%%; height: auto;">
  <div style="margin-top:8px; font-size:90%%; color:#555; text-align:justify;">
    <b>Figura:</b> distribuições binomiais $B(4, p)$ para dois casos extremos: $p \\to 0$ e $p \\to 1$. 
    No primeiro caso, a probabilidade concentra-se em $k = 0$, enquanto no segundo caso a concentração está em $k = 4$. 
    Esses cenários mostram como valores extremos de $p$ resultam em distribuições altamente concentradas em um único valor de $k$.
  </div>
</div>
', img_b64))

# Instale os pacotes se necessário
# install.packages("animation")
# install.packages("base64enc")
# install.packages("IRdisplay")

library(animation)
library(base64enc)
library(IRdisplay)

# Número de tentativas
n <- 3
k <- 0:n

# Função para plotar a distribuição binomial
binom_plot <- function(p) {
  y <- dbinom(k, size = n, prob = p)
  barplot(y,
          names.arg = k,
          col = "steelblue",
          ylim = c(0, 1),
          main = paste("Distribuição Binomial - n =", n, ", p =", round(p, 1)),
          xlab = "Número de sucessos (k)",
          ylab = "P(X = k)")
}

# img_path do arquivo GIF
gif_path <- "D:/g_drive/docencia/uff/disciplinas/posgrad/vis_rep_data/jupiter/figs/binomial_animation.gif"

# Suprimir todas as saídas do saveGIF
invisible({
  sink(tempfile())  # Redireciona saída padrão
  try(
    suppressMessages(suppressWarnings(
      saveGIF({
        for (p in seq(0.1, 1, by = 0.1)) {
          binom_plot(p)
        }
      }, movie.name = gif_path,
         interval = 0.8, ani.width = 600, ani.height = 400)
    )),
    silent = TRUE
  )
  sink()  # Restaura a saída padrão
})

# Codificar o GIF como base64 (silencioso)
invisible(gif_b64 <- dataURI(file = gif_path, mime = "image/gif"))

display_html(sprintf('
<div style="text-align:center; max-width: 100%%;">
  <img src="%s" style="max-width: 100%%; height: auto;">
  <div style="margin-top:8px; font-size:90%%; color:#555; text-align:justify;">
    <b>Figura:</b> animação da distribuição binomial $B(3, p)$ variando o valor de $p$ de 0,1 até 1,0. 
    A probabilidade concentra-se nos valores de $k$ mais próximos de $np$, 
    mostrando como o formato da distribuição se desloca e se modifica conforme $p$ aumenta.
  </div>
</div>
', gif_b64))

library(base64enc)
library(IRdisplay)

# Dados da população
x <- 1:3
p <- c(0.2, 0.5, 0.3)

# Valor esperado (centro de massa)
E_X <- sum(x * p)

# Variância populacional (com divisor n)
var_pop <- sum((x - E_X)^2 * p)
#invisible(cat(sprintf("Var(X) = %.4f\n", var_pop)))  # Esperado: 0.49

# img_paths de salvamento
local_path <- "valor_esperado_pop.png"
img_path <- "D:/g_drive/docencia/uff/disciplinas/posgrad/vis_rep_data/jupiter/figs/valor_esperado_pop.png"

# Salvar figura
png(local_path, width = 700, height = 400)

# Gráfico de barras
barplot(p, names.arg = x, col = "steelblue",
        main = "Centro de Massa (Valor Esperado)",
        xlab = "X", ylab = "P(X = x)", ylim = c(0, max(p) + 0.1))

# Adicionar linha e texto do valor esperado
arrows(x0 = E_X, y0 = max(p) + 0.05,
       x1 = E_X, y1 = 0, col = "red", lwd = 2, lty = 2)
text(E_X, max(p) + 0.08, labels = sprintf("E[X] = %.2f", E_X),
     col = "red", cex = 0.9)

invisible(dev.off())  # Fecha o dispositivo gráfico

# Copiar imagem para pasta final
invisible(file.copy(local_path, img_path, overwrite = TRUE))

# Converter para base64
img_b64 <- dataURI(file = img_path, mime = "image/png")

# Exibir centralizado no notebook
display_html(sprintf('
<div style="text-align:center; max-width: 100%%;">
  <img src="%s" style="max-width: 100%%; height: auto;">
  <div style="margin-top:8px; font-size:90%%; color:#555; text-align:justify;">
    <b>Figura:</b> distribuição de probabilidade da variável $X$ com valores $1$, $2$ e $3$. 
    A linha tracejada em vermelho indica o valor esperado $E[X] = %.2f$, 
    representando o centro de massa da distribuição.
  </div>
</div>
', img_b64, E_X))

# Criar e salvar os dois gráficos lado a lado no diretório atual
png("bernoulli_comparativo.png", width = 800, height = 300)
par(mfrow = c(1, 2))

# Valores possíveis de X
x <- c(0, 1)

# Probabilidades para p = 0.05
p1 <- c(0.95, 0.05)

# Probabilidades para p = 0.20
p2 <- c(0.80, 0.20)

# Primeiro gráfico
barplot(p1, names.arg = x, col = "steelblue",
        main = "Bernoulli(p = 0.05)", xlab = "X", ylab = "P(X)",
        ylim = c(0, 1))

# Segundo gráfico
barplot(p2, names.arg = x, col = "tomato",
        main = "Bernoulli(p = 0.20)", xlab = "X", ylab = "P(X)",
        ylim = c(0, 1))
invisible(dev.off())

# Copiar para diretório externo
invisible(file.copy("bernoulli_comparativo.png",
          to = "D:/g_drive/docencia/uff/disciplinas/posgrad/vis_rep_data/jupiter/figs/bernoulli_comparativo.png",
          overwrite = TRUE))
img_path = "D:/g_drive/docencia/uff/disciplinas/posgrad/vis_rep_data/jupiter/figs/bernoulli_comparativo.png"

# Converter para base64
img_b64 <- dataURI(file = img_path, mime = "image/png")

# Exibir centralizado no notebook
display_html(sprintf('
<div style="text-align:center; max-width: 100%%;">
  <img src="%s" style="max-width: 100%%; height: auto;">
  <div style="margin-top:8px; font-size:90%%; color:#555; text-align:justify;">
    <b>Figura:</b> comparação de distribuições de Bernoulli para $p = 0.05$ e $p = 0.20$. 
    À medida que $p$ aumenta, a probabilidade associada a $X = 1$ cresce e a de $X = 0$ diminui, 
    modificando a concentração da distribuição.
  </div>
</div>
', img_b64))

# Carregar biblioteca
library(IRdisplay)

# Intervalo para X
k_full <- 0:50
k_a <- 0:20

# Distribuições com mesma média, mas variâncias diferentes
p_A <- dbinom(k_a, size = 20, prob = 0.5)       # Menor variância
p_B <- dbinom(k_full, size = 200, prob = 0.05)  # Maior variância

# Salvar figura como PNG
png("comparacao_dispersao.png", width = 900, height = 400)
par(mfrow = c(1, 2))

barplot(p_A, names.arg = k_a, col = "steelblue",
        main = "Bin(20, 0.5) - Menor dispersão",
        ylab = "P(X = k)", xlab = "k", ylim = c(0, max(p_A, p_B)))

barplot(p_B, names.arg = k_full, col = "tomato",
        main = "Bin(200, 0.05) - Maior dispersão",
        ylab = "P(X = k)", xlab = "k", ylim = c(0, max(p_A, p_B)))



# Gerar e salvar a figura original
png("comparacao_dispersao.png", width = 800, height = 400)
plot(1:10, 1:10, main = "Exemplo Comparação Dispersão")
dev.off()  # fecha o dispositivo e grava o arquivo

# Copiar imagem para pasta de destino
file.copy("comparacao_dispersao.png",
          to = "D:/g_drive/docencia/uff/disciplinas/posgrad/vis_rep_data/jupiter/figs/comparacao_dispersao.png",
          overwrite = TRUE)

# Definir caminho final
img_path <- "D:/g_drive/docencia/uff/disciplinas/posgrad/vis_rep_data/jupiter/figs/comparacao_dispersao.png"

# Converter para base64
library(base64enc)
library(IRdisplay)
img_b64 <- dataURI(file = img_path, mime = "image/png")

# Exibir centralizado no notebook
display_html(sprintf('
<div style="text-align:center; max-width: 100%%;">
  <img src="%s" style="max-width: 100%%; height: auto;">
  <div style="margin-top:8px; font-size:90%%; color:#555; text-align:justify;">
    <b>Figura:</b> comparação de duas distribuições binomiais com a mesma média e variâncias diferentes. 
    A primeira, $B(20, 0.5)$, apresenta menor dispersão em torno da média, enquanto a segunda, $B(200, 0.05)$, apresenta maior dispersão. 
    A diferença na largura das distribuições ilustra o efeito da variância sobre a concentração das probabilidades.
  </div>
</div>
', img_b64))

library(base64enc)
library(IRdisplay)

# Parâmetros
n <- 5
p <- 0.1
k <- 0:n

# Probabilidades da distribuição binomial
y <- dbinom(k, size = n, prob = p)

# Salvar figura como PNG
png("binomial_pacotes_bloqueados.png", width = 600, height = 400)

# Gráfico
barplot(y, names.arg = k, col = "steelblue",
        main = "Distribuição Binomial (n = 5, p = 0.1)",
        xlab = "Número de pacotes bloqueados (k)",
        ylab = "P(X = k)",
        ylim = c(0, max(y) + 0.05))

invisible(dev.off())

# Copiar para diretório externo, se necessário
invisible(file.copy("binomial_pacotes_bloqueados.png",
          to = "D:/g_drive/docencia/uff/disciplinas/posgrad/vis_rep_data/jupiter/figs/binomial_pacotes_bloqueados.png",
          overwrite = TRUE))

# Converter para base64 para funcionar no nbviewer
img_b64 <- dataURI(file = "binomial_pacotes_bloqueados.png", mime = "image/png")

# Exibir centralizado no notebook
display_html(sprintf('
<div style="display: flex; flex-direction: column; justify-content: center; align-items: center; height: 100vh;">
  <div style="text-align:center">
    <img src="%s" width="600">
    <div style="margin-top:8px; font-size:90%%; color:#555; text-align:justify;">
      Figura 1: a maior barra está em $k=0$, indicando que o evento mais provável é nenhum pacote ser bloqueado, 
      com probabilidade próxima a 60%%. Isso se deve à baixa probabilidade de bloqueio ($p=0.1$). 
      A cauda longa e a assimetria à esquerda são características de distribuições binomiais com probabilidades próximas de zero.
    </div>
  </div>
</div>
', img_b64))

# Parâmetros
n <- 5
p <- 0.5
k <- 0:n

# Probabilidades da distribuição binomial
y <- dbinom(k, size = n, prob = p)

# Salvar figura como PNG
png("binomial_pacotes_bloqueados_p05.png", width = 600, height = 400)

# Gráfico
barplot(y, names.arg = k, col = "steelblue",
        main = "Distribuição Binomial (n = 5, p = 0.5)",
        xlab = "Número de pacotes bloqueados (k)",
        ylab = "P(X = k)",
        ylim = c(0, max(y) + 0.05))

invisible(dev.off())

# Copiar para diretório externo, se necessário
invisible(file.copy("binomial_pacotes_bloqueados_p05.png",
          to = "D:/g_drive/docencia/uff/disciplinas/posgrad/vis_rep_data/jupiter/figs/binomial_pacotes_bloqueados_p05.png",
          overwrite = TRUE))

# Exibir centralizado no notebook
library(IRdisplay)

display_html(sprintf('
<div style="text-align:center; max-width: 100%%;">
  <img src="%s" style="max-width: 100%%; height: auto;">
  <div style="margin-top:8px; font-size:90%%; color:#555; text-align:justify;">
    <b>Figura:</b> distribuição binomial $B(5, 0.5)$ da variável $X$, que representa o número de pacotes bloqueados em cinco tentativas independentes. 
    A simetria em torno de $k = 2$ e $k = 3$ resulta do fato de $p = 0.5$, que torna sucessos e falhas igualmente prováveis, 
    concentrando a maior parte da probabilidade nos valores próximos à média $np = 2.5$.
  </div>
</div>
', dataURI(file = "D:/g_drive/docencia/uff/disciplinas/posgrad/vis_rep_data/jupiter/figs/binomial_pacotes_bloqueados_p05.png", mime = "image/png")))

library(ggplot2)
library(base64enc)
library(IRdisplay)

# --- Parâmetros da distribuição ---
k <- 0:3
lambda <- 1
prob <- dpois(k, lambda)

# --- Criar dataframe para ggplot ---
df <- data.frame(k = factor(k), prob = prob)

# --- Criar gráfico com ggplot2 ---
p <- ggplot(df, aes(x = k, y = prob)) +
  geom_bar(stat = "identity", fill = "steelblue", width = 0.7) +
  geom_text(aes(label = round(prob, 3)), vjust = -0.5, size = 4) +
  labs(title = expression(paste("Distribuição de Poisson com ", lambda, " = 1")),
       x = "k", 
       y = "P(X = k)") +
  ylim(0, max(prob) + 0.1) +
  theme_minimal() +
  theme(plot.title = element_text(hjust = 0.5))

# --- Salvar como PNG e converter para base64 ---
img_path <- tempfile(fileext = ".png")
ggsave(img_path, p, width = 6, height = 4, dpi = 100)
img_b64 <- base64enc::dataURI(file = img_path, mime = "image/png")

# --- Exibir no Jupyter com legenda ---
display_html(sprintf('
<div style="text-align:center; margin:20px 0;">
  <img src="%s" style="max-width:100%%; height:auto;">
  <div style="margin-top:10px; font-size:0.9em; color:#555;">
    Figura: Distribuição de Poisson com $\\lambda = 1$. A maior probabilidade ocorre em $k = 1$.
  </div>
</div>', img_b64))

library(base64enc)
library(IRdisplay)

# --- Gerar e salvar a figura ---
png("poisson_lambdas.png", width = 800, height = 300)

# Suporte da variável
k <- 0:8

# Configurar layout: 1 linha, 3 colunas
par(mfrow = c(1, 3))

# Vetor de lambdas e cores
lambdas <- c(1, 2, 3)
cores <- c("steelblue", "tomato", "darkgreen")

# Loop para plotar os 3 gráficos
for (i in seq_along(lambdas)) {
  lambda <- lambdas[i]
  p <- dpois(k, lambda)
  barplot(p, names.arg = k, col = cores[i],
          main = bquote(Poisson(lambda == .(lambda))),
          xlab = "k", ylab = "P(X = k)", ylim = c(0, max(p) + 0.05))
  text(x = seq_along(k), y = p + 0.02, labels = round(p, 2), cex = 0.8)
}

invisible(dev.off())

# Copiar para diretório externo (opcional)
invisible(file.copy("poisson_lambdas.png",
                    to = "D:/g_drive/docencia/uff/disciplinas/posgrad/vis_rep_data/jupiter/figs/poisson_lambdas.png",
                    overwrite = TRUE))

# Converter para base64
img_b64 <- dataURI(file = "poisson_lambdas.png", mime = "image/png")

# Exibir figura centralizada no Jupyter
display_html(sprintf('
  <div style="display: flex; flex-direction: column; justify-content: center; align-items: center; height: 100vh;">
    div style="text-align:center; max-width: 100%%;">
      <img src="%s" width="700">
      <div style="margin-top:8px; font-size:90%%; color:#555;">
        Figura: a visualização dos gráficos abaixo mostra que com o crescimento de lambda, 
        a distribuição de Poisson tende a se comportar como a normal. 
        Na realidade para valores próximos de $\\lambda=30$ é comum essa análise.
        Para $\\lambda=1$ a curva formada pelos histogramas da esquerda para a direita é claramente assimétrica, 
        tendendo à simetrização com o aumento de $\\lambda$.
      </div>
    </div>
  </div>
', img_b64))

# Instale os pacotes se necessário
# install.packages("base64enc")
# install.packages("IRdisplay")

library(base64enc)
library(IRdisplay)

# Parâmetros da binomial
n <- 10
p <- 0.95
k <- 0:n
y <- dbinom(k, size = n, prob = p)

# img_path do arquivo PNG
img_path <- "D:/g_drive/docencia/uff/disciplinas/posgrad/vis_rep_data/jupiter/figs/binomial_n10_p95.png"

# Gerar o gráfico e salvar (em silêncio)
invisible({
  png(img_path, width = 700, height = 400)
  barplot(y,
          names.arg = k,
          col = "steelblue",
          ylim = c(0, max(y) + 0.05),
          main = "Distribuição Binomial (n = 10, p = 0.95)",
          xlab = "Número de sucessos (k)",
          ylab = "P(X = k)")
  invisible(dev.off())
})

# Codificar imagem como base64
invisible(img_b64 <- dataURI(file = img_path, mime = "image/png"))

display_html(sprintf('
<div style="text-align:center; max-width: 100%%;">
  <img src="%s" style="max-width: 100%%; height: auto;">
  <div style="margin-top:8px; font-size:90%%; color:#555; text-align:justify;">
    <b>Figura:</b> distribuição binomial $B(10, 0.95)$ da variável $X$, que representa o número de sucessos em dez tentativas independentes. 
    A probabilidade concentra-se nos valores mais próximos de $k = 10$, refletindo a alta probabilidade de sucesso em cada tentativa. 
    Isso resulta em uma distribuição assimétrica à esquerda, com baixa probabilidade para valores pequenos de $k$.
  </div>
</div>
', img_b64))

# Carregar bibliotecas necessárias
library(base64enc)
library(IRdisplay)

# Parâmetros da distribuição binomial
n <- 20
p <- 0.1
k <- 0:n
y <- dbinom(k, size = n, prob = p)

# img_path para salvar a figura
img_path <- "D:/g_drive/docencia/uff/disciplinas/posgrad/vis_rep_data/jupiter/figs/binomial_n20_p01.png"

# Gerar e salvar o gráfico (modo silencioso)
invisible({
  png(img_path, width = 700, height = 400)
  barplot(y,
          names.arg = k,
          col = "steelblue",
          ylim = c(0, max(y) + 0.02),
          main = "Distribuição Binomial (n = 20, p = 0.1)",
          xlab = "Número de sucessos (k)",
          ylab = "P(X = k)")
  invisible(dev.off())
})

# Codificar imagem como base64
invisible(img_b64 <- dataURI(file = img_path, mime = "image/png"))

display_html(sprintf('
<div style="text-align:center; max-width: 100%%;">
  <img src="%s" style="max-width: 100%%; height: auto;">
  <div style="margin-top:8px; font-size:90%%; color:#555; text-align:justify;">
    <b>Figura:</b> distribuição binomial $B(20, 0.1)$ da variável $X$, que representa o número de sucessos em vinte tentativas independentes. 
    A probabilidade concentra-se nos valores próximos de $k = 2$, que corresponde à média $np = 2$. 
    A baixa probabilidade de sucesso em cada tentativa gera uma distribuição assimétrica à direita, com cauda estendida para valores maiores de $k$.
  </div>
</div>
', img_b64))

# Instale os pacotes se necessário
# install.packages("base64enc")
# install.packages("IRdisplay")

library(base64enc)
library(IRdisplay)

# Parâmetros da binomial
n <- 30
p <- 0.02
k <- 0:n
y <- dbinom(k, size = n, prob = p)

# img_path para salvar o gráfico
img_path <- "D:/g_drive/docencia/uff/disciplinas/posgrad/vis_rep_data/jupiter/figs/binomial_n30_p02.png"

# Gerar e salvar a figura (sem ruído)
invisible({
  png(img_path, width = 700, height = 400)
  barplot(y,
          names.arg = k,
          col = "steelblue",
          ylim = c(0, max(y) + 0.02),
          main = "Distribuição Binomial (n = 30, p = 0.02)",
          xlab = "Número de sucessos (k)",
          ylab = "P(X = k)")
  invisible(dev.off())
})

# Codificar em base64
invisible(img_b64 <- dataURI(file = img_path, mime = "image/png"))

# Exibir centralizado (vertical + horizontal)
display_html(sprintf('
<div style="text-align:center; max-width: 100%%;">
  <img src="%s" style="max-width: 100%%; height: auto;">
  <div style="margin-top:8px; font-size:90%%; color:#555; text-align:justify;">
    <b>Figura:</b> distribuição binomial $B(30, 0.02)$ da variável $X$, que representa o número de sucessos em trinta tentativas independentes. 
    A probabilidade concentra-se fortemente em $k = 0$ e $k = 1$, refletindo a raridade do evento de sucesso. 
    A baixa taxa de sucesso provoca uma distribuição altamente assimétrica à direita, com valores grandes de $k$ apresentando probabilidades próximas de zero.
  </div>
</div>
', img_b64))

# Instale os pacotes se necessário
# install.packages("base64enc")
# install.packages("IRdisplay")

library(base64enc)
library(IRdisplay)

# Parâmetros
n <- 15
p <- 0.9
k <- 0:n
y <- dbinom(k, size = n, prob = p)

# img_path do arquivo
img_path <- "D:/g_drive/docencia/uff/disciplinas/posgrad/vis_rep_data/jupiter/figs/binomial_n15_p09.png"

# Gerar e salvar a figura (silenciosamente)
invisible({
  png(img_path, width = 700, height = 400)
  barplot(y,
          names.arg = k,
          col = "steelblue",
          ylim = c(0, max(y) + 0.05),
          main = "Distribuição Binomial (n = 15, p = 0.9)",
          xlab = "Número de sucessos (k)",
          ylab = "P(X = k)")
  invisible(dev.off())
})

# Codificar como base64
invisible(img_b64 <- dataURI(file = img_path, mime = "image/png"))

# Exibir centralizado vertical e horizontalmente
display_html(sprintf('
<div style="text-align:center; max-width: 100%%;">
  <img src="%s" style="max-width: 100%%; height: auto;">
  <div style="margin-top:8px; font-size:90%%; color:#555; text-align:justify;">
    <b>Figura:</b> distribuição binomial $B(15, 0.9)$ da variável $X$, que representa o número de sucessos em quinze tentativas independentes. 
    A probabilidade concentra-se em valores próximos de $k = 14$ e $k = 15$, refletindo a alta taxa de sucesso por tentativa. 
    A distribuição apresenta assimetria à esquerda, com baixa probabilidade para valores pequenos de $k$.
  </div>
</div>
', img_b64))

# Instale os pacotes se necessário
# install.packages("base64enc")
# install.packages("IRdisplay")

library(base64enc)
library(IRdisplay)

# Parâmetros da binomial
n <- 40
p <- 0.05
k <- 0:n
y <- dbinom(k, size = n, prob = p)

# img_path da figura
img_path <- "D:/g_drive/docencia/uff/disciplinas/posgrad/vis_rep_data/jupiter/figs/binomial_n40_p05.png"

# Gerar e salvar figura silenciosamente
invisible({
  png(img_path, width = 700, height = 400)
  barplot(y,
          names.arg = k,
          col = "steelblue",
          ylim = c(0, max(y) + 0.01),
          main = "Distribuição Binomial (n = 40, p = 0.05)",
          xlab = "Número de sucessos (k)",
          ylab = "P(X = k)")
  invisible(dev.off())
})

# Codificar como base64
invisible(img_b64 <- dataURI(file = img_path, mime = "image/png"))

# Exibir centralizado no notebook (horizontal e vertical)
display_html(sprintf('
<div style="text-align:center; max-width: 100%%;">
  <img src="%s" style="max-width: 100%%; height: auto;">
  <div style="margin-top:8px; font-size:90%%; color:#555; text-align:justify;">
    <b>Figura:</b> distribuição binomial $B(40, 0.05)$ da variável $X$, que representa o número de sucessos em quarenta tentativas independentes. 
    A probabilidade concentra-se em valores próximos de $k = 2$, que corresponde à média $np = 2.0$. 
    A baixa taxa de sucesso provoca uma distribuição assimétrica à direita, com valores maiores de $k$ apresentando probabilidades muito pequenas.
  </div>
</div>
', img_b64))

# Carrega igraph silenciosamente e gerencia namespaces
suppressPackageStartupMessages({
  suppressWarnings(
    library(igraph, exclude = c("decompose", "spectrum", "union"))
  )
})  # Fechando ambos os parênteses que estavam abertos

# Dados da árvore de probabilidade
edges <- data.frame(
  from = c("Root", "Root", "VLAN10", "Outras"),
  to = c("VLAN10", "Outras", "Legítimo_VLAN10", "Legítimo_Outras"),
  label = c("10%", "90%", "90%", "40%")
)

# Rótulos dos nós
vertex_labels <- c(
  "Root" = "Pacotes\n100%",
  "VLAN10" = "VLAN10\n10%",
  "Outras" = "Outras VLANs\n90%",
  "Legítimo_VLAN10" = "Legítimos\n90%",
  "Legítimo_Outras" = "Legítimos\n40%"
)

# Cores dos nós
vertex_colors <- c(
  "Root" = "darkblue",
  "VLAN10" = "orange",
  "Outras" = "orange",
  "Legítimo_VLAN10" = "lightgreen",
  "Legítimo_Outras" = "lightgreen"
)

# Criar grafo
g <- graph_from_data_frame(edges)

# Caminho temporário da imagem
img_path <- tempfile(fileext = ".png")

# Salvar a árvore como PNG
png(img_path, width = 800, height = 500)
plot(
  g,
  layout = layout_as_tree(g, root = 1),
  vertex.size = 35,
  vertex.color = vertex_colors[names(V(g))],
  vertex.label = vertex_labels[names(V(g))],
  vertex.label.cex = 0.8,
  vertex.label.color = "black",
  edge.label = edges$label,
  edge.label.cex = 0.9,
  edge.label.color = "darkred",
  edge.arrow.size = 0.4,
  main = "Árvore de Probabilidade de Pacotes",
  margin = c(0,0,0.2,0)
)
dev.off()

# Converter para Base64 (usando a função correta)
library(base64enc)
img_b64 <- base64encode(img_path)

# Texto final com imagem embutida
texto_md <- sprintf('
O switch registra que **10%%** dos pacotes vêm da VLAN 10.  
Desses, **90%%** são legítimos.  
Nos demais (**90%%** dos pacotes), apenas **40%%** são legítimos.

** Diagrama de Árvore Probabilística:**

<img src="data:image/png;base64,%s" width="600">

**Legenda:**  
<ul>
  <li><b>VLAN10 (10%%):</b> 90%% legítimos</li>
  <li><b>Outras VLANs (90%%):</b> 40%% legítimos</li>
  <li><b>Probabilidade total legítima:</b> (0.1 × 0.9) + (0.9 × 0.4) = <b>45%%</b></li>
</ul>
', img_b64)

# Exibir no notebook
library(IRdisplay)
display_markdown(texto_md)

library(igraph)
library(base64enc)
library(IRdisplay)

# Dados da árvore
edges <- data.frame(
  from = c("Pacotes", "Pacotes", "VLAN 10", "VLAN 10", "Outras VLANs", "Outras VLANs"),
  to   = c("VLAN 10", "Outras VLANs", "Legítimos VLAN 10", "Ilegítimos VLAN 10",
           "Legítimos outras VLANs", "Ilegítimos outras VLANs")
)

# Rótulos com probabilidades
labels <- c(
  "Pacotes",
  "VLAN 10\n10%",
  "Outras VLANs\n90%",
  "Legítimos\n90%",
  "Ilegítimos\n10%",
  "Legítimos\n40%",
  "Ilegítimos\n60%"
)

# Criar grafo
g <- graph_from_data_frame(edges)

# Caminho temporário da imagem
img_path <- tempfile(fileext = ".png")

# Salvar a árvore como PNG
png(img_path, width = 800, height = 500)
plot(
  g,
  layout = layout_as_tree(g, root = 1),
  vertex.size = 35,
  vertex.color = "lightblue",
  vertex.label = labels,
  vertex.label.cex = 0.8,
  vertex.label.color = "black",
  edge.arrow.size = 0.4
)
dev.off()

# Converter para Base64
img_b64 <- dataURI(file = img_path, mime = "image/png")

# Texto final com imagem embutida
texto_md <- sprintf('
O switch registra que **10%%** dos pacotes vêm da VLAN 10.  
Desses, **90%%** são legítimos.  
Nos demais (**90%%** dos pacotes), apenas **40%%** são legítimos.

**✦ Tarefa extra:** diagrama de árvore representando os eventos e probabilidades envolvidos.

<img src="%s" width="600">
', img_b64)

# Exibir no notebook
display_markdown(texto_md)

# Pacotes
library(ggplot2)
library(base64enc)
library(IRdisplay)

# Dados
labels <- c(
  "Classe=0, A=0, B=0", "Classe=0, A=0, B=1", "Classe=0, A=1, B=0", "Classe=0, A=1, B=1",
  "Classe=1, A=0, B=0", "Classe=1, A=0, B=1", "Classe=1, A=1, B=0", "Classe=1, A=1, B=1"
)
probs <- c(0.3825, 0.0425, 0.0675, 0.0075, 0.0075, 0.0675, 0.0425, 0.3825)

df <- data.frame(Comb = factor(labels, levels = labels), Prob = probs)

# Gráfico (ggplot) — atribuir a 'p' para uso também no RGui
p <- ggplot(df, aes(x = Comb, y = Prob)) +
  geom_col(fill = "skyblue") +
  labs(title = "Distribuição Conjunta: Classe × A × B", x = NULL, y = "Probabilidade") +
  scale_y_continuous(limits = c(0, 0.45)) +
  coord_cartesian(clip = "off") +
  theme_minimal(base_size = 12) +
  theme(
    axis.text.x = element_text(angle = 45, hjust = 1),
    plot.margin = margin(10, 10, 30, 10)
  )

# Salvar e embutir em Base64 (para Jupyter)
img_path <- tempfile(fileext = ".png")
ggsave(filename = img_path, plot = p, width = 9, height = 5, dpi = 130)
img_b64 <- dataURI(file = img_path, mime = "image/png")

# Exibir com legenda justificada (Jupyter)
display_html(sprintf('
<div style="text-align:center; max-width:100%%;">
  <img src="%s" style="max-width:100%%; height:auto;">
  <div style="margin-top:12px; font-size:90%%; color:#555; text-align:justify; max-width:1000px; margin:0 auto;">
    <b>Figura:</b> distribuição conjunta de (Classe, A, B). As probabilidades somam 1. 
    A maior massa está nas combinações concordantes, (Classe=0, A=0, B=0) e (Classe=1, A=1, B=1), ambas com 0.3825. 
    Combinações discordantes têm menor probabilidade, refletindo alinhamento entre Classe e saídas dos sensores A e B.
  </div>
</div>
', img_b64))

# Observação: no RGui/RStudio, basta executar `print(p)` para visualizar o gráfico.

library(base64enc)
library(IRdisplay)

# Caminho temporário da imagem
img_path <- tempfile(fileext = ".png")

# Salvar o gráfico
png(img_path, width = 700, height = 400)
tipos <- c("Interativo" = 0.45,
           "Em Lote"    = 0.35,
           "Streaming"  = 0.20)

b <- barplot(tipos,
             col = "steelblue",
             main = "Distribuição dos Pacotes por Tipo de Serviço",
             ylab = "Probabilidade",
             ylim = c(0, 0.5))

# Adiciona os valores no topo das barras
text(x = b,
     y = tipos + 0.02,
     labels = paste0(round(tipos * 100), "%"),
     cex = 1,
     font = 2)
dev.off()

# Converter para base64
img_b64 <- dataURI(file = img_path, mime = "image/png")

# Exibir no notebook com legenda
display_html(sprintf('
<div style="text-align:center; max-width: 100%%;">
  <img src="%s" style="max-width: 100%%; height: auto;">
  <div style="margin-top:8px; font-size:90%%; color:#555; text-align:justify;">
    <b>Figura:</b> distribuição dos pacotes por tipo de serviço. 
    O tipo interativo concentra 45%% do total, seguido por processamento em lote com 35%% e transmissão em streaming com 20%%. 
    Os valores indicam a proporção de cada categoria em relação ao total de pacotes.
  </div>
</div>
', img_b64))

library(base64enc)
library(IRdisplay)

# Caminho temporário para salvar a imagem
img_path <- tempfile(fileext = ".png")

# Salvar gráfico
png(img_path, width = 800, height = 500)
probs <- c(0.12, 0.08, 0.016, 0.784)
labels <- c("Suspeito e Malicioso", "Suspeito e Não Malicioso",
            "Não Suspeito e Malicioso", "Não Suspeito e Não Malicioso")

# Cria o barplot sem rótulos no eixo X
bp <- barplot(probs,
              names.arg = rep("", length(labels)),
              col = "steelblue",
              ylim = c(0, 0.8),
              main = "Ameaça vs Realidade",
              ylab = "Probabilidade")

# Adiciona os rótulos manualmente com rotação
text(x = bp,
     y = par("usr")[3] - 0.03,
     labels = labels,
     srt = 45,
     adj = 1,
     xpd = TRUE,
     cex = 0.8)
dev.off()

# Exibir embutido em base 64
img_b64 <- dataURI(file = img_path, mime = "image/png")

# Legenda no padrão
display_html(sprintf('
<div style="text-align:center; max-width: 100%%;">
  <img src="%s" style="max-width: 100%%; height: auto;">
  <div style="margin-top:8px; font-size:90%%; color:#555; text-align:justify;">
    <b>Figura:</b> relação entre suspeita e ocorrência real de atividades maliciosas. 
    A maior parte dos casos (78.4%%) corresponde a eventos não suspeitos e não maliciosos. 
    Casos suspeitos e maliciosos representam 12%%, enquanto suspeitos e não maliciosos são 8%%. 
    Situações não suspeitas, mas maliciosas, somam 1.6%%.
  </div>
</div>
', img_b64))

library(base64enc)
library(IRdisplay)

# Caminho temporário da imagem
img_path <- tempfile(fileext = ".png")

# Salvar o gráfico
png(img_path, width = 800, height = 500)
probs <- c(0.30 * 0.08, 0.30 * 0.92, 0.70 * 0.15, 0.70 * 0.85)
labels <- c("Urgente+Atraso", "Urgente+Sem Atraso",
            "Comum+Atraso", "Comum+Sem Atraso")

# Cria o barplot
bp <- barplot(probs,
              names.arg = rep("", length(labels)),
              col = "tomato",
              las = 2,
              main = "Atraso por Tipo de Pacote",
              ylim = c(0, 0.6),
              ylab = "Probabilidade")

# Adiciona rótulos
text(x = bp,
     y = par("usr")[3] - 0.03,
     labels = labels,
     srt = 45,
     adj = 1,
     xpd = TRUE,
     cex = 0.8)
dev.off()

# Exibir embutido em Base64
img_b64 <- dataURI(file = img_path, mime = "image/png")

# Legenda no padrão
display_html(sprintf('
<div style="text-align:center; max-width: 100%%;">
  <img src="%s" style="max-width: 100%%; height: auto;">
  <div style="margin-top:8px; font-size:90%%; color:#555; text-align:justify;">
    <b>Figura:</b> atraso por tipo de pacote. Pacotes urgentes com atraso representam %.3f da probabilidade total, 
    urgentes sem atraso %.3f, comuns com atraso %.3f e comuns sem atraso %.3f. 
    A distribuição evidencia que a maior parte dos pacotes é comum e sem atraso.
  </div>
</div>
', img_b64, probs[1], probs[2], probs[3], probs[4]))

library(ggplot2)
library(base64enc)
library(IRdisplay)

# Caminho temporário para salvar a imagem
img_path <- tempfile(fileext = ".png")

# Dados
probs <- c(0.15 * 0.90, 0.15 * 0.10, 0.85 * 0.05, 0.85 * 0.95)
labels <- c("Ataque Detectado", "Ataque Não Detectado",
            "Normal com Alerta", "Normal sem Alerta")

df <- data.frame(
  Categoria = labels,
  Probabilidade = probs
)

# Salvar o gráfico
png(img_path, width = 800, height = 500)
ggplot(df, aes(x = Categoria, y = Probabilidade)) +
  geom_col(fill = "orange") +
  labs(title = "Resposta do IDS", y = "Probabilidade", x = NULL) +
  theme_minimal() +
  theme(axis.text.x = element_text(angle = 45, hjust = 1))
dev.off()

# Exibir embutido em Base64
img_b64 <- dataURI(file = img_path, mime = "image/png")

# exibir embutido em base64
display_html(sprintf('
<div style="text-align:center; max-width: 100%%;">
  <img src="%s" style="max-width: 100%%; height: auto;">
  <div style="margin-top:8px; font-size:90%%; color:#555; text-align:justify;">
    <b>Figura:</b> resposta do IDS. Ataques detectados correspondem a %.3f da probabilidade total, 
    ataques não detectados %.3f, tráfego normal com alerta %.3f e tráfego normal sem alerta %.3f. 
    A maior parte dos eventos corresponde a tráfego normal sem alerta.
  </div>
</div>
', img_b64, probs[1], probs[2], probs[3], probs[4]))

library(ggplot2)
library(base64enc)
library(IRdisplay)

# Caminho temporário para salvar a imagem
img_path <- tempfile(fileext = ".png")

# Dados
probs <- c(0.6 * 0.90, 0.6 * 0.10, 0.4 * 0.30, 0.4 * 0.70)
labels <- c("Prioritário+Entrega", "Prioritário+Perda",
            "Comum+Entrega", "Comum+Perda")

df <- data.frame(
  Categoria = labels,
  Probabilidade = probs
)

# Salvar o gráfico
png(img_path, width = 800, height = 500)
ggplot(df, aes(x = Categoria, y = Probabilidade)) +
  geom_col(fill = "darkgreen") +
  labs(title = "Entrega de Pacotes por Classe", y = "Probabilidade", x = NULL) +
  theme_minimal() +
  theme(axis.text.x = element_text(angle = 45, hjust = 1))
dev.off()

# Converter para Base64
img_b64 <- dataURI(file = img_path, mime = "image/png")

# Exibir embutido base 64
display_html(sprintf('
<div style="text-align:center; max-width: 100%%;">
  <img src="%s" style="max-width: 100%%; height: auto;">
  <div style="margin-top:8px; font-size:90%%; color:#555; text-align:justify;">
    <b>Figura:</b> entrega de pacotes por classe. Pacotes prioritários entregues representam %.3f da probabilidade total, 
    prioritários perdidos %.3f, comuns entregues %.3f e comuns perdidos %.3f. 
    Observa-se predominância de entregas, especialmente na classe prioritária.
  </div>
</div>
', img_b64, probs[1], probs[2], probs[3], probs[4]))

library(ggplot2)
library(base64enc)
library(IRdisplay)

# Caminho temporário para salvar a imagem
img_path <- tempfile(fileext = ".png")

# Dados de exemplo (substituir conforme necessário)
df <- data.frame(
  Categoria = c("Servidor A", "Servidor B", "Servidor C", "Servidor D"),
  Probabilidade = c(0.25, 0.15, 0.40, 0.20)
)

# Salvar o gráfico
png(img_path, width = 800, height = 500)
ggplot(df, aes(x = Categoria, y = Probabilidade)) +
  geom_col(fill = "brown") +
  labs(title = "Falhas por Servidor", y = "Probabilidade", x = NULL) +
  theme_minimal() +
  theme(axis.text.x = element_text(angle = 45, hjust = 1))
dev.off()

# Exibir embutido base 64
img_b64 <- dataURI(file = img_path, mime = "image/png")

display_html(sprintf('
<div style="text-align:center; max-width: 100%%;">
  <img src="%s" style="max-width: 100%%; height: auto;">
  <div style="margin-top:8px; font-size:90%%; color:#555; text-align:justify;">
    <b>Figura:</b> distribuição de falhas por servidor. O Servidor A representa %.2f da probabilidade total de falhas, 
    o Servidor B %.2f, o Servidor C %.2f e o Servidor D %.2f. 
    A concentração de falhas no Servidor C sugere possível necessidade de manutenção preventiva ou investigação adicional.
  </div>
</div>
', img_b64, df$Probabilidade[1], df$Probabilidade[2], df$Probabilidade[3], df$Probabilidade[4]))

library(ggplot2)
library(gridExtra)
library(base64enc)
library(IRdisplay)

# Função para gerar gráfico com curva normal e intervalo sombreado com cores customizáveis
plot_z_conf <- function(z, conf_level, curva_color, sombra_color) {
  x <- seq(-4, 4, length.out = 1000)
  y <- dnorm(x)
  df <- data.frame(x = x, y = y)
  shade <- subset(df, x >= -z & x <= z)

  ggplot(df, aes(x, y)) +
    geom_line(color = curva_color, linewidth = 1.2) +
    geom_area(data = shade, aes(x, y), fill = sombra_color, alpha = 0.4) +
    geom_vline(xintercept = c(-z, z), linetype = "dashed", color = "gray40") +
    labs(
      title = paste("Intervalo de Confiança", conf_level, "%"),
      subtitle = paste("z = ±", z),
      x = "z", y = "densidade"
    ) +
    theme_minimal(base_size = 13)
}

# Criar os dois gráficos com cores distintas
g90 <- plot_z_conf(1.64, 90, curva_color = "darkgreen", sombra_color = "lightgreen")
g95 <- plot_z_conf(1.96, 95, curva_color = "navy", sombra_color = "skyblue")

# Salvar imagem temporária com os dois gráficos lado a lado
tmpfile <- tempfile(fileext = ".png")
png(tmpfile, width = 1200, height = 500, res = 100)
grid.arrange(g90, g95, ncol = 2)
dev.off()

# Converter para base64
img_b64 <- dataURI(file = tmpfile, mime = "image/png")

# Exibir centralizado no notebook
display_html(sprintf('
<div style="text-align:center; max-width: 100%%;">
  <img src="%s" style="max-width: 100%%; height: auto;">
  <div style="margin-top:8px; font-size:90%%; color:#555; text-align:justify;">
    <b>Figura:</b> comparação dos intervalos de confiança de 90%% e 95%% sob a curva normal padrão. 
    O intervalo de 95%% (à direita) é mais amplo, refletindo maior nível de confiança à custa de um maior valor crítico de $z$. 
    O intervalo de 90%% (à esquerda) é mais estreito, resultando em menor valor crítico e menor cobertura.
  </div>
</div>
', img_b64))

# Dados observados
carga <- c(10, 20, 30, 40, 50, 60, 70)
latencia <- c(20, 23, 26, 27, 33, 35, 36)

# Ajuste do modelo de regressão linear
modelo <- lm(latencia ~ carga)

# Cálculo dos valores ajustados (estimados) e dos resíduos
valores_estimados <- predict(modelo)
residuos <- resid(modelo)

# Combinar os resultados em um data frame para visualização
resultado <- data.frame(
  Carga = carga,
  Latencia_Observada = latencia,
  Latencia_Estimada = round(valores_estimados, 2),
  Erro_Residual = round(residuos, 2)
)

library(ggplot2)
library(base64enc)
library(IRdisplay)

# Dados
carga <- c(10, 20, 30, 40, 50, 60, 70)
latencia <- c(20, 23, 26, 27, 33, 35, 36)
modelo <- lm(latencia ~ carga)
df <- data.frame(carga, latencia)

# Caminho temporário para salvar
img_path <- tempfile(fileext = ".png")

# Salvar o gráfico
png(img_path, width = 800, height = 500)
ggplot(df, aes(x = carga, y = latencia)) +
  geom_point(size = 3) +
  geom_smooth(method = "lm", se = FALSE, formula = y ~ x, color = "blue") +
  geom_segment(aes(xend = carga, yend = predict(modelo)),
               color = "red", linetype = "dashed") +
  labs(title = "Latência vs Carga da Rede",
       x = "Carga (%)",
       y = "Latência (ms)")
dev.off()

# Converter para Base64
img_b64 <- dataURI(file = img_path, mime = "image/png")

# Exibir com legenda
display_html(sprintf('
<div style="text-align:center; max-width: 100%%;">
  <img src="%s" style="max-width: 100%%; height: auto;">
  <div style="margin-top:8px; font-size:90%%; color:#555; text-align:justify;">
    <b>Figura:</b> relação entre carga da rede e latência. 
    Os pontos representam as observações medidas, a linha azul mostra o ajuste por regressão linear 
    e as linhas tracejadas vermelhas indicam os resíduos de cada ponto em relação ao modelo ajustado. 
    O gráfico evidencia tendência de aumento da latência conforme cresce a carga da rede.
  </div>
</div>
', img_b64))

real <- c(0.2, 0.5, 0.8, 0.3, 0.6)
previsto <- c(0.3, 0.4, 0.7, 0.2, 0.5)

library(ggplot2)
library(base64enc)
library(IRdisplay)

# 1. Primeiro, precisamos criar o df_long que está faltando
# Exemplo com dados simulados:
set.seed(123)
df_long <- data.frame(
  Observação = rep(1:5, 3),
  Valor = c(rnorm(5, mean=10),          # Valores reais
                rnorm(5, mean=9.8),     # Valores previstos
                rnorm(5, mean=0.2)),    # Resíduos
  Tipo = rep(c("Real", "Previsto", "Resíduo"), each=5)
)

# 2. Agora podemos criar o gráfico
p <- ggplot(df_long, aes(x = factor(Observação), y = Valor, fill = Tipo)) +
  geom_bar(stat = "identity", position = position_dodge(width = 0.8)) +
  scale_fill_manual(values = c("steelblue", "orange", "firebrick")) +
  labs(title = "Comparação: Valores Reais, Previstos e Resíduos",
       x = "Observação", y = "Valor") +
  theme_minimal()

# 3. Salvar e exibir o gráfico
img_path <- tempfile(fileext = ".png")
ggsave(filename = img_path, plot = p, width = 8, height = 5, dpi = 100)
img_b64 <- base64encode(img_path)  # Corrigido para usar base64enc

display_html(sprintf('
<div style="text-align:center; max-width: 100%%;">
  <img src="data:image/png;base64,%s" style="max-width: 100%%; height: auto;">
  <div style="margin-top:8px; font-size:90%%; color:#555; text-align:justify;">
    <b>Figura:</b> comparação entre os valores reais, previstos e os resíduos (diferença entre eles) 
    para cinco observações. A visualização permite identificar a precisão da previsão: resíduos menores 
    indicam maior aderência do modelo aos dados reais.
  </div>
</div>
', img_b64))

# Limpeza (opcional)
unlink(img_path)

#Função para execução no R
intervalo_confianca <- function(x_bar, s, n, z) {
  erro_padrao <- s / sqrt(n)
  margem <- z * erro_padrao
  c(inferior = x_bar - margem, superior = x_bar + margem)
}

# Carregar bibliotecas
library(ggplot2)
library(base64enc)
library(IRdisplay)

# Gerar dados
set.seed(135)
media_real <- 52
n <- 10
medias <- rnorm(n, mean = media_real, sd = 2)
erro <- 1.96 * 2 / sqrt(30)

# Criar data frame
df <- data.frame(
  id = 1:n,
  media = medias,
  lower = medias - erro,
  upper = medias + erro
)

# Gerar gráfico
p <- ggplot(df, aes(x = id, y = media)) +
  geom_point(size = 2) +
  geom_errorbar(aes(ymin = lower, ymax = upper), width = 0.2) +
  geom_hline(yintercept = media_real, color = "red", linetype = "dashed") +
  labs(title = "Intervalos de Confiança (95%) para Latência Média",
       x = "Sub-rede", y = "Latência (ms)") +
  theme_minimal()

# Salvar imagem temporária
img_path <- tempfile(fileext = ".png")
ggsave(img_path, plot = p, width = 8, height = 5, dpi = 100)

# Codificar para base64
img_b64 <- dataURI(file = img_path, mime = "image/png")

# Exibir no notebook com legenda
display_html(sprintf('
<div style="text-align:center; max-width: 100%%;">
  <img src="%s" style="max-width: 100%%; height: auto;">
  <div style="margin-top:8px; font-size:90%%; color:#555; text-align:justify;">
    <b>Figura:</b> intervalo de confiança de 95%% para a média da latência em diferentes sub-redes. 
    A linha tracejada vermelha representa o valor real de referência ($\\mu = %.0f$ ms). 
    Barras que não cruzam essa linha indicam estimativas estatisticamente diferentes da média real.
  </div>
</div>
', img_b64, media_real))

# Pacotes necessários
library(ggplot2)
library(base64enc)
library(IRdisplay)

# Dados dos dois provedores
media_A <- 22.3
media_B <- 21.8
desvio_A <- 1.8
desvio_B <- 2.1
n_A <- 30
n_B <- 30

# Estatística do teste t de Welch
s2_A <- desvio_A^2
s2_B <- desvio_B^2
erro_padrao <- sqrt(s2_A / n_A + s2_B / n_B)
t_obs <- (media_A - media_B) / erro_padrao

# Graus de liberdade de Welch
df <- (s2_A / n_A + s2_B / n_B)^2 /
      ((s2_A / n_A)^2 / (n_A - 1) + (s2_B / n_B)^2 / (n_B - 1))

# Valor-p (teste bicaudal)
p_valor <- 2 * pt(-abs(t_obs), df)

# Criar o gráfico com ggplot2
p <- ggplot(data.frame(x = c(-4, 4)), aes(x)) +
  stat_function(fun = dt, args = list(df = df), 
                color = "steelblue", linewidth = 1) +
  geom_vline(xintercept = c(-t_obs, t_obs), 
             color = "red", linetype = "dashed", linewidth = 1) +
  labs(title = paste("Distribuição t de Welch (df =", round(df, 1), ")"),
       subtitle = paste("Teste t para amostras independentes com variâncias desiguais"),
       x = "Estatística t",
       y = "Densidade") +
  annotate("text", x = 0, y = 0.3, 
           label = paste("t observado =", round(t_obs, 2)), 
           color = "red") +
  theme_minimal()

# Salvar o gráfico como imagem temporária
img_path <- tempfile(fileext = ".png")
ggsave(img_path, p, width = 7, height = 4, dpi = 100)

# Codificar em Base64
img_b64 <- dataURI(file = img_path, mime = "image/png")

# Exibir no notebook com legenda justificada
display_html(sprintf('
<div style="display: flex; flex-direction: column; align-items: center;">
  <img src="%s" width="700">
  <div style="margin-top: 10px; font-size: 90%%; color: #555; text-align: justify; max-width: 700px;">
    <b>Figura:</b> Distribuição t de Welch com %.1f graus de liberdade ajustados. As linhas vermelhas indicam o valor observado da estatística t (t = %.2f) e seu simétrico sob a hipótese nula. O valor-p bicaudal do teste de Welch é %.4f, indicando a probabilidade de observar uma diferença tão extrema quanto %.2f ms entre as médias, assumindo igualdade populacional.
  </div>
</div>
', img_b64, df, t_obs, p_valor, media_A-media_B))

library(ggplot2)
library(base64enc)
library(IRdisplay)

# Dados
protocolos <- c("OSPF", "BGP", "EIGRP", "RIP", "ISIS", "MPLS")
pvalores <- c(0.012, 0.045, 0.083, 0.20, 0.003, 0.051)
df <- data.frame(protocolos, pvalores)

# Criar gráfico
p <- ggplot(df, aes(x = reorder(protocolos, -pvalores), y = pvalores)) +
  geom_col(fill = c("#d62728", "#1f77b4", "#ff7f0e", "#2ca02c", "#9467bd", "#8c564b")) +
  geom_hline(yintercept = 0.05, linetype = "dashed", color = "red", linewidth = 1) +
  geom_text(aes(label = pvalores), vjust = -0.5, size = 3.5) +
  labs(title = "Valores-p por Protocolo de Roteamento",
       subtitle = "Linha vermelha: limiar de significância (α = 0.05)",
       x = "Protocolo",
       y = "Valor-p") +
  theme_minimal() +
  theme(axis.text.x = element_text(angle = 45, hjust = 1, size = 11),
        plot.subtitle = element_text(color = "red"))

# Salvar como imagem temporária
img_path <- tempfile(fileext = ".png")
ggsave(img_path, p, width = 8, height = 5, dpi = 100)

# Codificar em Base64
img_b64 <- dataURI(file = img_path, mime = "image/png")

display_html(sprintf('
<div style="text-align:center; max-width:100%%;">
  <img src="%s" style="max-width:100%%; height:auto;">
  <div style="margin-top:12px; font-size:90%%; color:#555; text-align:justify; max-width:900px; margin:0 auto;">
    <b>Figura:</b> valores-p de seis protocolos de roteamento comparados ao nível de significância α = 0.05 (linha vermelha). Resultados significativos (p < 0.05) foram observados para ISIS (0.003), OSPF (0.012) e BGP (0.045), enquanto MPLS (0.051), EIGRP (0.083) e RIP (0.20) não atingiram significância estatística.
  </div>
</div>
', img_b64))

 qnorm(1 - 0.01 / 2) = 2.575829

library(ggplot2)
library(gridExtra)
library(base64enc)
library(IRdisplay)

# Parameters
t_obs <- -2.5
alpha <- 0.05
df <- 99

# ---------- t-Distribution ----------
x_t <- seq(-4, 4, length.out = 1000)
df_t <- data.frame(x = x_t, y = dt(x_t, df))
crit_t <- qt(alpha, df)

g1 <- ggplot(df_t, aes(x, y)) +
  geom_line(color = "#1f77b4", linewidth = 1.2) +
  geom_vline(xintercept = crit_t, linetype = "dashed", color = "#d62728", linewidth = 1) +
  geom_vline(xintercept = t_obs, color = "darkgreen", linewidth = 1.2) +
  geom_area(data = subset(df_t, x <= crit_t), aes(x, y), fill = "#ff9896", alpha = 0.5) +
  annotate("text", x = crit_t-0.2, y = 0.05, label = paste0("t crit = ", round(crit_t,3)), 
           color = "#d62728", angle = 90, hjust = 1) +
  annotate("text", x = t_obs-0.2, y = 0.05, label = paste0("t obs = ", t_obs), 
           color = "darkgreen", angle = 90, hjust = 1) +
  labs(title = "Distribuição t-student (df = 99)", x = "t", y = "Density") +
  theme_minimal()

# ---------- z-Distribution ----------
x_z <- seq(-4, 4, length.out = 1000)
df_z <- data.frame(x = x_z, y = dnorm(x_z))
crit_z <- qnorm(alpha)

g2 <- ggplot(df_z, aes(x, y)) +
  geom_line(color = "#9467bd", linewidth = 1.2) +
  geom_vline(xintercept = crit_z, linetype = "dashed", color = "#e377c2", linewidth = 1) +
  geom_vline(xintercept = t_obs, color = "darkgreen", linewidth = 1.2) +
  geom_area(data = subset(df_z, x <= crit_z), aes(x, y), fill = "#f7b6d2", alpha = 0.5) +
  annotate("text", x = crit_z-0.2, y = 0.05, label = paste0("z crit = ", round(crit_z,3)), 
           color = "#e377c2", angle = 90, hjust = 1) +
  annotate("text", x = t_obs-0.2, y = 0.05, label = paste0("z obs = ", t_obs), 
           color = "darkgreen", angle = 90, hjust = 1) +
  labs(title = "Distribuição normal", x = "z", y = "Density") +
  theme_minimal()

# Combine plots and save directly to base64 without displaying
img_path <- tempfile(fileext = ".png")
png(img_path, width = 1000, height = 400)
grid.arrange(g1, g2, ncol = 2)
invisible(dev.off())

# Encode as Base64
img_b64 <- base64encode(img_path)

# Display only once with detailed caption
display_html(sprintf('
<div style="display:flex; flex-direction:column; align-items:center; margin:20px 0;">
  <img src="data:image/png;base64,%s" style="max-width:900px; width:100%%;">
  <div style="margin-top:20px; font-size:0.9em; color:#555; text-align:justify; max-width:800px;">
    <p><b>Figura Esquerda (Distribuição t):</b> Distribuição t-Student com %d graus de liberdade. Linha vermelha tracejada = valor crítico t (%.3f) para α=0,05. Linha verde = valor t observado (%.1f) na região de rejeição (p=%.4f).</p>
    <p><b>Figura Direita (Distribuição Normal):</b> Distribuição normal padrão para comparação. Linha rosa tracejada = valor z crítico (%.3f). O mesmo valor observado cai na região de rejeição, demonstrando como as distribuições t se aproximam da normal quando os graus de liberdade aumentam.</p>
    <p><b>Conclusão:</b> Como nosso valor observado (t=%.1f) está na região de rejeição em ambas as distribuições, <span style="color:#d62728; font-weight:bold;">rejeitamos a hipótese nula</span> com nível de significância de 5%%.</p>
  </div>
</div>', 
img_b64, df, crit_t, t_obs, pt(t_obs, df), crit_z, t_obs))

# Clean up
unlink(img_path)

qt(1 - alpha/2, df = n - 1)
## Para 90%
qt(0.05, df = 29) = 1.699
## Para 95%
qt(0.025, df = 29) = 2.045
## Para 99%
qt(0.005, df = 29) = 2.756

library(ggplot2)
library(base64enc)
library(IRdisplay)

# Dados do teste Z
z_obs <- -2.36
p_valor <- pnorm(z_obs)

# Criar o gráfico sem warnings
p <- ggplot(data.frame(x = c(-4, 4)), aes(x)) +
  stat_function(fun = dnorm, 
                args = list(mean = 0, sd = 1), 
                linewidth = 1, 
                color = "black") +
  
  # Área do p-valor
  stat_function(fun = dnorm,
                args = list(mean = 0, sd = 1),
                xlim = c(-4, z_obs),
                geom = "area",
                fill = "red", 
                alpha = 0.5) +
  
  # Linha vertical
  geom_vline(xintercept = z_obs, 
             color = "red", 
             linetype = "dashed", 
             linewidth = 1) +
  
  # Anotações (substituindo expression() por parse(text=))
  annotate("text", 
           x = z_obs, 
           y = dnorm(z_obs),
           label = "Z == -2.36", 
           parse = TRUE,
           hjust = -0.2, 
           color = "red") +
  
  annotate("text",
           x = -3.4,
           y = 0.02,
           label = paste0("p-valor = ", format.pval(p_valor, digits = 4)),
           color = "red") +
  
  # Título com notação matemática segura
  labs(title = "Distribuição Normal Padrão: P(Z ≤ -2.36)",
       x = "Estatística Z", 
       y = "Densidade") +
  
  theme_minimal() +
  scale_x_continuous(breaks = seq(-4, 4, by = 1))

# Exportação para Base64 (mantido igual)
img_path <- tempfile(fileext = ".png")
ggsave(img_path, p, width = 7, height = 5, dpi = 100)
img_b64 <- dataURI(file = img_path, mime = "image/png")

# Exibição com legenda
display_html(sprintf('
<div style="display: flex; flex-direction: column; align-items: center;">
  <img src="%s" width="700">
  <div style="margin-top: 10px; font-size: 90%%; color: #555; text-align: justify; max-width: 700px;">
    <b>Figura:</b> Distribuição Normal Padrão mostrando a probabilidade acumulada P(Z ≤ %.2f) = %.4f. A área vermelha representa a probabilidade de observar valores tão extremos quanto Z = %.2f ou menores sob a hipótese nula.
  </div>
</div>
', img_b64, z_obs, p_valor, z_obs))

library(ggplot2)
library(base64enc)
library(IRdisplay)

# Parâmetros do teste
t_obs <- 6.45
df <- 14
alpha <- 0.05
t_crit <- qt(1 - alpha, df)
p_valor <- pt(t_obs, df, lower.tail = FALSE)

# Criar o gráfico sem warnings
p <- ggplot(data.frame(x = seq(-1, 7, length.out = 1000)), aes(x)) +
  
  # Curva t de Student
  stat_function(fun = dt, args = list(df = df), 
                color = "black", linewidth = 1.2) +
  
  # Área de rejeição (α)
  stat_function(fun = dt, args = list(df = df),
                xlim = c(t_crit, 7),
                geom = "area",
                fill = "lightcoral", alpha = 0.6) +
  
  # Linhas críticas
  geom_vline(xintercept = t_crit, 
             color = "red", linetype = "dashed", linewidth = 1.2) +
  geom_vline(xintercept = t_obs, 
             color = "blue", linetype = "dashed", linewidth = 1.2) +
  
  # Anotações (modificadas para evitar warnings)
  annotate("text", x = t_crit, y = 0.12, 
           label = paste0("t crítico = ", round(t_crit, 2)),
           color = "red", angle = 90, vjust = -0.5, hjust = 0) +
  
  annotate("text", x = t_obs, y = 0.1, 
           label = paste0("t observado = ", round(t_obs, 2)),
           color = "blue", angle = 90, vjust = -0.5, hjust = 0) +
  
  # Substituição do expression() por parse(text=)
  annotate("text", x = t_crit + 1.3, y = 0.05,
           label = "alpha == P(Rejeitar*H[0]*' | '*H[0]*' é verdadeira')",
           parse = TRUE,  # Indica que o texto deve ser interpretado como expressão
           hjust = 0, color = "darkred", size = 3.5) +
  
  # Seta explicativa
  annotate("segment", 
           x = t_crit + 1.2, xend = t_crit + 0.3,
           y = 0.045, yend = dt(t_crit + 0.5, df) * 0.8,
           arrow = arrow(length = unit(0.25, "cm"), type = "closed"), 
           color = "darkred", linewidth = 0.8) +
  
  labs(
    title = paste0("Teste t Unilateral (α = ", alpha, ") com ", df, " graus de liberdade"),
    subtitle = "Área de rejeição da hipótese nula",
    x = "Estatística t",
    y = "Densidade de probabilidade"
  ) +
  
  theme_minimal() +
  theme(plot.subtitle = element_text(color = "gray40"))

# Salvar e exibir
img_path <- tempfile(fileext = ".png")
ggsave(img_path, p, width = 8, height = 5, dpi = 100)
img_b64 <- dataURI(file = img_path, mime = "image/png")

display_html(sprintf('
<div style="display: flex; flex-direction: column; align-items: center;">
  <img src="%s" width="800">
  <div style="margin-top: 10px; font-size: 90%%; color: #555; text-align: justify; max-width: 700px;">
    <b>Figura:</b> Distribuição t de Student com %d graus de liberdade. A área vermelha (α = %.2f) representa a região de rejeição unilateral direita. A linha vermelha marca t crítico = %.2f (q<sub>%.3f</sub>), enquanto a azul mostra t observado = %.2f. O p-valor (P(T ≥ %.2f) = %.1e) é < %.3f, indicando rejeição de H₀. A seta vermelha ilustra α como probabilidade de erro Tipo I sob H₀ verdadeira.
  </div>
</div>
', img_b64, df, alpha, t_crit, 1-alpha, t_obs, t_obs, p_valor, alpha))

library(ggplot2)
library(base64enc)
library(IRdisplay)

# Parâmetros
media <- 35
ep <- 7 / sqrt(500)  # erro padrão
z <- 1.96  # valor z para 95% de confiança
lim_inf <- media - z * ep
lim_sup <- media + z * ep
confianca <- 0.95

# Criar o gráfico
p <- ggplot(data.frame(x = seq(media - 4*ep, media + 4*ep, length.out = 1000)), aes(x)) +
  
  # Curva normal
  stat_function(fun = dnorm, 
                args = list(mean = media, sd = ep),
                color = "black", 
                linewidth = 1) +
  
  # Área do intervalo de confiança
  stat_function(fun = dnorm,
                args = list(mean = media, sd = ep),
                xlim = c(lim_inf, lim_sup),
                geom = "area",
                fill = "skyblue", 
                alpha = 0.5) +
  
  # Linhas de referência
  geom_vline(xintercept = media, 
             linetype = "dashed", 
             color = "blue", 
             linewidth = 1.2) +
  
  geom_vline(xintercept = c(lim_inf, lim_sup), 
             color = "red", 
             linetype = "dotted",
             linewidth = 1) +
  
  # Anotações
  annotate("text", 
           x = media, 
           y = max(dnorm(media, media, ep)) * 0.9,
           label = paste0("μ = ", media), 
           color = "blue", 
           angle = 90, 
           vjust = -0.5) +
  
  annotate("text",
           x = lim_inf,
           y = max(dnorm(media, media, ep)) * 0.6,
           label = sprintf("IC(95%%) inf. = %.3f", lim_inf),
           angle = 0,
           hjust = 1.2,
           color = "red") +
  
  annotate("text",
           x = lim_sup-0.2,
           y = max(dnorm(media, media, ep)) * 0.6,
           label = sprintf("IC(95%%) sup. = %.3f", lim_sup),
           angle = 0,
           hjust = -0.5,
           color = "red") +
  
  labs(
    title = paste0("Distribuição Amostral da Média com IC de ", confianca*100, "%"),
    subtitle = paste0("Erro padrão = ", round(ep, 3), " | n = 500"),
    x = "Média amostral", 
    y = "Densidade"
  ) +
  
  theme_minimal() +
  theme(plot.subtitle = element_text(color = "gray40"))

# Salvar como imagem temporária
img_path <- tempfile(fileext = ".png")
ggsave(img_path, p, width = 8, height = 5, dpi = 100)

# Codificar em Base64
img_b64 <- dataURI(file = img_path, mime = "image/png")

display_html(sprintf('
<div style="display: flex; flex-direction: column; align-items: center;">
  <img src="%s" width="800">
  <div style="margin-top: 10px; font-size: 90%%; color: #555; text-align: justify; max-width: 700px;">
    <b>Figura:</b> Distribuição amostral da média (Teorema Central do Limite) com desvio padrão σ/√n = %.3f. A área azul representa o intervalo de confiança de %.0f%% (%.3f a %.3f), contendo o parâmetro populacional μ com %.0f%% de confiança. O IC foi calculado como μ ± z<sub>α/2</sub>·(σ/√n), onde z<sub>%.3f</sub> = %.2f. A linha azul tracejada indica a estimativa pontual (%.1f).
  </div>
</div>
', img_b64, ep, confianca*100, lim_inf, lim_sup, confianca*100, 1-(1-confianca)/2, z, media))

library(ggplot2)
library(base64enc)
library(IRdisplay)
library(gridExtra)

# === GRÁFICO 1: Teste Z Bicaudal ===

z_obs <- 1.86
alpha <- 0.05
z_crit <- qnorm(1 - alpha / 2)  # Definindo z_crit aqui
p_valor <- 2 * pnorm(-abs(z_obs)) # Cálculo do p-valor bicaudal

g1 <- ggplot(data.frame(x = seq(-4, 4, length.out = 1000)), aes(x)) +
  stat_function(fun = dnorm, color = "black", linewidth = 1.2) +
  
  # Áreas de rejeição
  stat_function(fun = dnorm, xlim = c(z_crit, 4),
                geom = "area", fill = "red", alpha = 0.5) +
  stat_function(fun = dnorm, xlim = c(-4, -z_crit),
                geom = "area", fill = "red", alpha = 0.5) +
  
  # Linhas críticas
  geom_vline(xintercept = c(-z_crit, z_crit), 
             linetype = "dashed", color = "red", linewidth = 1) +
  geom_vline(xintercept = c(-z_obs, z_obs), 
             linetype = c("dotted", "dashed"), color = "blue", linewidth = 1) +
  
  # Anotações
  annotate("text", x = z_crit + 0.1, y = 0.05,
           label = paste0("z crítico = ±", round(z_crit, 2)),
           color = "red", hjust = 0) +
  annotate("text", x = z_obs, y = 0.15,
           label = paste0("z observado = ", round(z_obs, 2)),
           color = "blue", hjust = -0.2) +
  annotate("text", x = 0, y = 0.3,
           label = paste0("p-valor = ", round(p_valor, 4)),
           color = "black") +
  
  labs(title = "Teste Z Bicaudal",
       subtitle = expression(paste("Hipótese nula: ", mu == 0, " vs Alternativa: ", mu != 0)),
       x = "Estatística Z", 
       y = "Densidade") +
  theme_minimal()

# === GRÁFICO 2: Intervalo de Confiança ===

dif <- 0.04
SE <- 0.0215
IC <- c(dif - z_crit * SE, dif + z_crit * SE)  # Usando z_crit aqui
contem_zero <- IC[1] <= 0 && IC[2] >= 0

g2 <- ggplot(data.frame(
  estimativa = dif,
  ICmin = IC[1],
  ICmax = IC[2],
  grupo = "Diferença"
), aes(x = grupo, y = estimativa)) +
  geom_point(size = 4, color = "black") +
  geom_errorbar(aes(ymin = ICmin, ymax = ICmax), 
               width = 0.2, linewidth = 1.2, color = "blue") +
  geom_hline(yintercept = 0, linetype = "dashed", color = "red") +
  ylim(-0.05, 0.1) +
  labs(title = "Intervalo de Confiança (95%)",
       subtitle = paste0("Diferença de proporções: ", round(dif, 4), 
                        " ± ", round(z_crit * SE, 4)),
       y = "Diferença (p1 - p2)", 
       x = "") +
  annotate("text", x = 0.4, y = 0.005, 
           label = ifelse(contem_zero, 
                          " Nesse caso Inclui zero → Não significativo"),
           hjust = 0, color = "red") +
  theme_minimal() +
  theme(axis.text.x = element_blank())

# === Combinar e exportar ===
combined <- grid.arrange(g1, g2, ncol = 2)

# Salvar como imagem
img_path <- tempfile(fileext = ".png")
ggsave(img_path, combined, width = 12, height = 5, dpi = 100)

# Codificar em Base64
img_b64 <- base64encode(img_path)

# Exibir com legenda (MANTIDA COMO ORIGINAL)
display_html(sprintf('
<div style="display: flex; flex-direction: column; align-items: center;">
  <img src="%s" width="1000">
  <div style="margin-top: 20px; font-size: 90%%; color: #555; text-align: justify; max-width: 1000px;">
    <p><b>Gráfico 1 (Esquerda) - Teste Z:</b> A estatística observada (Z = %.2f) está dentro da região de aceitação (|Z| ≤ %.2f). O p-valor de %.4f é maior que α = 0.05, então <b>não rejeitamos H₀: μ = 0</b>. Isso indica que a diferença observada não é estatisticamente significativa.</p>
    <p><b>Gráfico 2 (Direita) - Intervalo de Confiança:</b> O IC 95%% [%.4f, %.4f] inclui o valor zero, que está  na premissa das hipóteses ($p_1$ diferente de $p_2$). Isso significa que a diferença observada (%.4f) é <b>compatível com H₀</b>. Os dois métodos (Teste Z e IC) levam à mesma conclusão, indicando que não há evidência suficiente para rejeitar a hipótese nula.</p>
  </div>
</div>
', img_b64, z_obs, z_crit, p_valor, IC[1], IC[2], dif))

# Limpeza (opcional)
unlink(img_path)

library(ggplot2)
library(base64enc)
library(IRdisplay)

# Parâmetros do problema
t_obs <- 7.97
df <- 24
alpha <- 0.01
t_crit <- qt(1 - alpha, df)
p_valor <- pt(t_obs, df, lower.tail = FALSE)

# Criar o gráfico
p <- ggplot(data.frame(x = seq(-1, 9, length.out = 1000)), aes(x)) +
  stat_function(fun = dt, args = list(df = df), color = "black", linewidth = 1.2) +
  
  # Área de rejeição
  stat_function(fun = dt, args = list(df = df), xlim = c(t_crit, 9),
               geom = "area", fill = "lightcoral", alpha = 0.6) +
  
  # Linhas críticas
  geom_vline(xintercept = t_crit, color = "red", linetype = "dashed", linewidth = 1.2) +
  geom_vline(xintercept = t_obs, color = "blue", linetype = "dashed", linewidth = 1.2) +
  
  # Anotações
  annotate("text", x = t_crit, y = 0.11, 
           label = paste0("t crítico = ", round(t_crit, 3)),
           color = "red", angle = 90, vjust = -0.5, hjust = 0) +
  
  annotate("text", x = t_obs, y = 0.1, 
           label = paste0("t observado = ", round(t_obs, 2)),
           color = "blue", angle = 90, vjust = -0.5, hjust = 0) +
  
  annotate("text", x = t_crit + 0.7, y = 0.035,
           label = "α = P(Rejeitar H0 | H0 é verdadeira)",
           hjust = 0, color = "darkred", size = 4) +
  
  # Seta corrigida (parêntese fechado)
  annotate("segment", x = t_crit + 0.5, xend = t_crit + 0.1,
           y = 0.02, yend = dt(t_crit + 0.5, df) * 0.7,
           arrow = arrow(length = unit(0.3, "cm")), color = "darkred") +
  
  labs(
    title = "Distribuição t de Student sob H0",
    subtitle = paste0("Teste unilateral direito (α = ", alpha, ", df = ", df, ")"),
    x = "Estatística t",
    y = "Densidade"
  ) +
  theme_minimal()

# Salvar como imagem temporária
img_path <- tempfile(fileext = ".png")
ggsave(img_path, p, width = 8, height = 5, dpi = 100)

# Codificar em Base64
img_b64 <- dataURI(file = img_path, mime = "image/png")

display_html(sprintf('
<div style="display: flex; flex-direction: column; align-items: center;">
  <img src="%s" width="800">
  <div style="margin-top: 10px; font-size: 90%%; color: #555; text-align: justify; max-width: 700px;">
    <p><b>Interpretação:</b> O gráfico mostra a distribuição t com %d graus de liberdade sob H0. A área vermelha (α = %.2f) é a região de rejeição (t > %.3f). Como t observado = %.2f cai nesta região (p-valor = %.2e < α), <b>rejeitamos H0</b>. A seta indica a probabilidade de erro Tipo I.</p>
    <p><b>Conclusão:</b> Há evidência estatística (p < 0.01) para rejeitar H0 em favor da alternativa unilateral direita.</p>
  </div>
</div>
', img_b64, df, alpha, t_crit, t_obs, p_valor))

library(ggplot2)
library(base64enc)
library(IRdisplay)

# Parâmetros do problema
n <- 100
media <- 25
sd <- 3
alpha <- 0.05

# Cálculos estatísticos
erro_padrao <- sd / sqrt(n)
z_crit <- qnorm(1 - alpha / 2)
IC_inf <- media - z_crit * erro_padrao
IC_sup <- media + z_crit * erro_padrao

# Criar o gráfico
p <- ggplot(data.frame(
  estimativa = media,
  ICmin = IC_inf,
  ICmax = IC_sup,
  grupo = "Consumo médio"
), aes(x = grupo, y = estimativa)) +
  geom_point(size = 4, color = "blue") +
  geom_errorbar(aes(ymin = ICmin, ymax = ICmax), 
               width = 0.2, linewidth = 1.2, color = "blue") +
  geom_hline(yintercept = media, linetype = "dashed", color = "black", alpha = 0.5) +
  annotate("text", x = 0.8, y = media+0.1,
           label = paste0("Média = ", media, " mW"),
           color = "black") +
  annotate("text", x = 1, y = IC_inf - 0.5,
           label = paste0("IC 95% = [", round(IC_inf, 2), ", ", round(IC_sup, 2), "] mW"),
           color = "darkblue") +
  labs(
    title = "Intervalo de Confiança (95%) para Consumo de Energia",
    subtitle = paste0("n = ", n, ", DP = ", sd, " mW, Erro padrão = ", round(erro_padrao, 3)),
    y = "Consumo (mW)",
    x = ""
  ) +
  theme_minimal() +
  theme(axis.text.x = element_blank())

# Salvar como imagem temporária
img_path <- tempfile(fileext = ".png")
ggsave(img_path, p, width = 7, height = 5, dpi = 100)

# Codificar em Base64
img_b64 <- dataURI(file = img_path, mime = "image/png")

display_html(sprintf('
<div style="display:flex; flex-direction:column; align-items:center;">
  <img src="%s" width="700">
  <div style="margin-top:10px; font-size:90%%; color:#555; text-align:center; max-width:700px;">
    <b>Figura:</b> IC 95%% = [%.2f, %.2f] mW (Média = %.1f mW, EP = %.3f mW). Com 95%% de confiança, o verdadeiro consumo médio populacional está neste intervalo. Amplitude = %.2f mW (n = %d).
  </div>
</div>', 
img_b64, IC_inf, IC_sup, media, erro_padrao, IC_sup-IC_inf, n))

library(ggplot2)
library(base64enc)
library(IRdisplay)

# Parâmetros
z_obs <- 2.67
z_limite <- 2
x <- seq(-4, 4, length.out = 1000)
y <- dnorm(x)
df <- data.frame(x = x, y = y)

# Regiões incomuns (z > 2)
df_area_incomum <- subset(df, x >= z_limite)

# Criar o gráfico
p <- ggplot(df, aes(x = x, y = y)) +
  geom_line(color = "black", linewidth = 1.2) +
  
  # Região incomum (z > 2)
  geom_area(data = df_area_incomum, aes(x, y), fill = "orange", alpha = 0.5) +
  
  # Linhas verticais principais
  geom_vline(xintercept = z_obs, linetype = "dashed", color = "blue", linewidth = 1.2) +
  geom_vline(xintercept = z_limite, linetype = "dotted", color = "red", linewidth = 1) +
  
  # Marcação dos desvios padrão
  geom_vline(xintercept = -1, color = "darkgreen", linetype = "dashed") +
  geom_vline(xintercept = 1, color = "darkgreen", linetype = "dashed") +
  
  # Anotações
  annotate("text", x = z_obs, y = 0.15, 
           label = paste0("z = ", round(z_obs, 2)),
           color = "blue", angle = 90, vjust = -0.4, hjust = 0) +
  
  annotate("text", x = z_limite + 0.3, y = 0.05, 
           label = "Região incomum (z > 2)",
           color = "darkred", size = 4, hjust = 0) +
  
  annotate("text", x = 0, y = 0.25, 
           label = "±1 desvio padrão",
           color = "darkgreen", size = 4.2) +
  
  labs(
    title = "Distribuição Normal Padrão",
    subtitle = "Faixas de 1 desvio padrão e região incomum (z > 2)",
    x = "z",
    y = "Densidade"
  ) +
  theme_minimal() 

# Salvar como imagem temporária
img_path <- tempfile(fileext = ".png")
ggsave(img_path, p, width = 8, height = 5, dpi = 100)

# Codificar em Base64
img_b64 <- dataURI(file = img_path, mime = "image/png")
IRdisplay::display_html(sprintf('
<div style="text-align:center; max-width: 100%%;">
  <img src="%s" style="max-width: 100%%; height: auto;">
  <div style="margin-top:12px; font-size:90%%; color:#555; text-align:justify; max-width: 800px; margin-left:auto; margin-right:auto;">
    <b>Figura:</b> distribuição normal padrão com destaque para a faixa de ±1 desvio padrão (linhas verdes) e para a região incomum de cauda direita (z &gt; 2), sombreada em laranja. A linha azul indica o valor observado, z = %.2f, e a linha vermelha pontilhada marca o limite adotado (z = %.0f). A área sombreada representa a probabilidade de observar valores acima do limite sob N(0,1).
  </div>
</div>
', img_b64, z_obs, z_limite))

# Pacotes
library(ggplot2)
library(base64enc)
library(IRdisplay)

# Dados
desvio_padrao_pop <- 10
n_valores <- seq(5, 200, by = 5)
erro_padrao_valores <- desvio_padrao_pop / sqrt(n_valores)
df_ep <- data.frame(N = n_valores, Erro_Padrao = erro_padrao_valores)

# Gráfico (atribuir a 'p')
p <- ggplot(df_ep, aes(x = N, y = Erro_Padrao)) +
  geom_line(color = "darkblue", linewidth = 1) +
  geom_point(color = "darkblue", size = 2) +
  labs(title = "Erro Padrão da Média vs. Tamanho da Amostra",
       x = "Tamanho da Amostra (n)", y = "Erro Padrão da Média") +
  theme_minimal()

# Salvar e embutir em base64
img_path <- tempfile(fileext = ".png")
ggsave(filename = img_path, plot = p, width = 8, height = 5, dpi = 120)
img_b64 <- dataURI(file = img_path, mime = "image/png")

# Exibir com legenda
display_html(sprintf('
<div style="text-align:center; max-width: 100%%;">
  <img src="%s" style="max-width:100%%; height:auto;">
  <div style="margin-top:10px; font-size:90%%; color:#555; text-align:justify; max-width:800px; margin:0 auto;">
    <b>Figura:</b> relação entre o tamanho da amostra e o erro padrão da média, com $\\sigma = 10$ e $EP=\\sigma/\\sqrt{n}$. 
    O erro padrão decresce proporcionalmente a $1/\\sqrt{n}$; para reduzir o $EP$ pela metade, é necessário quadruplicar $n$. 
    O gráfico evidencia ganhos marginais decrescentes ao aumentar o tamanho amostral.
  </div>
</div>
', img_b64))

# Pacotes
library(ggplot2)
library(base64enc)
library(IRdisplay)

# Parâmetros do teste
z_obs  <- 1.18
alpha  <- 0.05
z_crit <- qnorm(1 - alpha)          # z crítico unilateral (cauda direita)
p_val  <- 1 - pnorm(z_obs)          # valor-p unilateral (direita)

# Dados da distribuição normal padrão
x  <- seq(-3.5, 3.5, length.out = 1000)
y  <- dnorm(x)
dfn <- data.frame(x = x, y = y)

# Região crítica (cauda direita)
df_rej <- subset(dfn, x >= z_crit)

# Gráfico (atribuir a 'p')
p <- ggplot(dfn, aes(x = x, y = y)) +
  geom_line(color = "black", linewidth = 1.2) +
  geom_area(data = df_rej, aes(x, y), fill = "orange", alpha = 0.6) +
  geom_vline(xintercept = z_obs,  color = "blue", linetype = "dashed", linewidth = 1.2) +
  geom_vline(xintercept = z_crit, color = "red",  linetype = "dashed", linewidth = 1.2) +
  annotate("text", x = z_obs, y = 0.10, label = sprintf("z obs = %.2f", z_obs),
           color = "blue", angle = 90, vjust = -0.5, hjust = 0) +
  annotate("text", x = z_crit, y = 0.12, label = sprintf("z crítico = %.3f", z_crit),
           color = "red", angle = 90, vjust = -0.5, hjust = 0) +
  annotate("text", x = z_crit + 0.2, y = 0.025, label = "Região crítica (α = 0.05)",
           color = "darkred", hjust = 0, size = 4) +
  labs(
    title = "Distribuição Normal Padrão — Teste de Hipótese Unilateral",
    subtitle = "Comparação entre tempos médios das versões A e B",
    x = "z", y = "Densidade"
  ) +
  theme_minimal()

# Salvar e embutir em base64
img_path <- tempfile(fileext = ".png")
ggsave(filename = img_path, plot = p, width = 8, height = 5, dpi = 120)
img_b64 <- dataURI(file = img_path, mime = "image/png")

display_html(sprintf('
<div style="text-align:center; max-width: 100%%;">
  <img src="%s" style="max-width:100%%; height:auto;">
  <div style="margin-top:10px; font-size:90%%; color:#555; text-align:justify; max-width:800px; margin:0 auto;">
    <b>Figura:</b> teste unilateral à direita com α = 0.05. A área em laranja indica a região crítica (z &gt; %.3f).
    A linha azul marca o valor observado, z = %.2f. O valor-p unilateral é %.4f; como z<sub>obs</sub> &lt; z<sub>crítico</sub>,
    não se rejeita H<sub>0</sub> ao nível de significância especificado.
  </div>
</div>
', img_b64, z_crit, z_obs, p_val))

# Pacotes
library(ggplot2)
library(base64enc)
library(IRdisplay)

# Dados
set.seed(18)
n_switches <- 15
media_pop <- 0.005
medias_amostrais <- rnorm(n_switches, mean = media_pop, sd = 0.002)
desvio_padrao_amostra <- 0.001
tamanho_amostra_ic <- 50
t_critico_90 <- qt(0.95, df = tamanho_amostra_ic - 1)  # IC 90% => cauda 5%
erro_margem <- t_critico_90 * (desvio_padrao_amostra / sqrt(tamanho_amostra_ic))

df_ic <- data.frame(
  id = 1:n_switches,
  media = medias_amostrais,
  lower = medias_amostrais - erro_margem,
  upper = medias_amostrais + erro_margem
)

# Gráfico (atribuir a 'p')
p <- ggplot(df_ic, aes(x = id, y = media)) +
  geom_point(size = 2) +
  geom_errorbar(aes(ymin = lower, ymax = upper), width = 0.2) +
  geom_hline(yintercept = media_pop, color = "red", linetype = "dashed", linewidth = 1) +
  labs(title = "Intervalos de Confiança (90%) para Perda de Pacotes em Switches",
       x = "ID do Switch", y = "Taxa de Perda de Pacotes") +
  theme_minimal()

# Salvar e embutir em base64
img_path <- tempfile(fileext = ".png")
ggsave(filename = img_path, plot = p, width = 8, height = 5, dpi = 120)
img_b64 <- dataURI(file = img_path, mime = "image/png")

# Exibir com legenda justificada
display_html(sprintf('
<div style="text-align:center; max-width: 100%%;">
  <img src="%s" style="max-width:100%%; height:auto;">
  <div style="margin-top:10px; font-size:90%%; color:#555; text-align:justify; max-width:800px; margin:0 auto;">
    <b>Figura:</b> intervalos de confiança de 90%% para a taxa de perda de pacotes por switch. A linha vermelha tracejada indica a taxa populacional de referência (%.4f). 
    Cada barra representa $\\hat{p}_i \\pm ME$, com $ME = t_{0.95,\\,df=%.0f} \\cdot s/\\sqrt{n} = %.5f$. 
    Barras que cruzam a linha de referência não fornecem evidência de diferença em relação à média populacional ao nível de 10%%, ou seja, capturam com pouco erro a média populacional.
  </div>
</div>
', img_b64, media_pop, tamanho_amostra_ic - 1, erro_margem))

# Pacotes
library(ggplot2)
library(base64enc)
library(IRdisplay)

# Parâmetros
z <- 2.4
pval <- pnorm(z, lower.tail = FALSE)  # P(Z >= z)

# Gráfico (atribuir a 'p')
p <- ggplot(data.frame(x = c(-4, 4)), aes(x)) +
  stat_function(fun = dnorm, geom = "line", linewidth = 1) +
  geom_area(stat = "function", fun = dnorm, xlim = c(z, 4),
            fill = "steelblue", alpha = 0.5) +
  geom_vline(xintercept = z, linetype = "dashed", color = "red", linewidth = 1) +
  annotate("text", x = z + 0.3, y = 0.05,
           label = sprintf("z = %.2f", z), color = "red") +
  annotate("text", x = 3, y = 0.15,
           label = sprintf("P(X ≥ 62) ≈ %.4f", pval),
           color = "blue", size = 4) +
  labs(title = "Distribuição Normal Padrão",
       x = "Z-score", y = "Densidade") +
  theme_minimal()

# Salvar e embutir em base64
img_path <- tempfile(fileext = ".png")
ggsave(filename = img_path, plot = p, width = 8, height = 5, dpi = 120)
img_b64 <- dataURI(file = img_path, mime = "image/png")

display_html(sprintf('
<div style="text-align:center; max-width: 100%%;">
  <img src="%s" style="max-width:100%%; height:auto;">
  <div style="margin-top:10px; font-size:90%%; color:#555; text-align:justify; max-width:800px; margin:0 auto;">
    <b>Figura:</b> probabilidade de cauda direita na N(0,1) para z = %.2f.
    A área sombreada representa $P(Z \\ge z) = %.4f$. A linha vermelha tracejada marca o z-score observado.
  </div>
</div>
', img_b64, z, pval))

# Pacotes
library(ggplot2)
library(base64enc)
library(IRdisplay)

# Parâmetros
alpha <- 0.05
gl1 <- 29
gl2 <- 24
F_obs <- 1.5

# Críticos bicaudais
F_crit_upper <- qf(1 - alpha/2, gl1, gl2)
F_crit_lower <- 1 / qf(1 - alpha/2, gl2, gl1)  # simétrico da cauda inferior

# Curva F
x <- seq(0.2, 3.5, length.out = 1000)
y <- df(x, gl1, gl2)
df_plot <- data.frame(x = x, y = y)

# Faixas de rejeição
rej_sup <- subset(df_plot, x >= F_crit_upper)
rej_inf <- subset(df_plot, x <= F_crit_lower)

# Decisão
rejeita <- (F_obs >= F_crit_upper) || (F_obs <= F_crit_lower)

# Gráfico (atribuir a 'p')
p <- ggplot(df_plot, aes(x = x, y = y)) +
  geom_line(linewidth = 1.2) +
  geom_area(data = rej_sup, aes(x, y), fill = "orange", alpha = 0.6) +
  geom_area(data = rej_inf, aes(x, y), fill = "orange", alpha = 0.6) +
  geom_vline(xintercept = F_obs, color = "blue", linetype = "dashed", linewidth = 1.2) +
  geom_vline(xintercept = F_crit_upper, color = "red", linetype = "dashed") +
  geom_vline(xintercept = F_crit_lower, color = "red", linetype = "dashed") +
  annotate("text", x = F_obs + 0.1, y = 0.2,
           label = sprintf("F_obs = %.2f", F_obs),
           color = "blue", angle = 90, vjust = -0.5) +
  annotate("text", x = F_crit_upper, y = 0.15,
           label = sprintf("F_crit_sup = %.3f", F_crit_upper),
           color = "red", angle = 90, vjust = -0.5) +
  annotate("text", x = F_crit_lower, y = 0.15,
           label = sprintf("F_crit_inf = %.3f", F_crit_lower),
           color = "red", angle = 90, vjust = -0.5) +
  labs(title = "Distribuição F (bicaudal)",
       subtitle = "Teste de homogeneidade de variâncias (α = 0.05)",
       x = "F", y = "Densidade") +
  theme_minimal()

# Salvar e embutir em base64
img_path <- tempfile(fileext = ".png")
ggsave(filename = img_path, plot = p, width = 8, height = 5, dpi = 120)
img_b64 <- dataURI(file = img_path, mime = "image/png")

# Exibir com legenda justificada
display_html(sprintf('
<div style="text-align:center; max-width:100%%;">
  <img src="%s" style="max-width:100%%; height:auto;">
  <div style="margin-top:10px; font-size:90%%; color:#555; text-align:justify; max-width:820px; margin:0 auto;">
    <b>Figura:</b> teste F bicaudal com gl<sub>1</sub> = %d e gl<sub>2</sub> = %d. 
    As áreas em laranja indicam as regiões críticas (F ≤ %.3f ou F ≥ %.3f). 
    A linha azul marca a estatística observada, F<sub>obs</sub> = %.2f. 
    Decisão ao nível α = 0.05: %s H<sub>0</sub> de igualdade de variâncias.
  </div>
</div>
', img_b64, gl1, gl2, F_crit_lower, F_crit_upper, F_obs,
   if (rejeita) "rejeita-se" else "não se rejeita"))

# Pacotes
library(ggplot2)
library(base64enc)
library(IRdisplay)

# Parâmetros do teste
delta <- -0.1     # redução esperada (negativa)
sd <- 0.2         # desvio padrão
alpha <- 0.05     # nível de significância (cauda esquerda)
power <- 0.8      # potência desejada

# Cálculo do tamanho da amostra (teste unilateral à esquerda)
z_alpha <- qnorm(alpha)       # negativo (cauda esquerda)
z_beta  <- qnorm(power)       # positivo
n <- ((z_alpha + z_beta) * sd / delta)^2
n <- ceiling(n)

# Valor crítico em escala da estatística (H0: mu = 0)
se <- sd / sqrt(n)
crit <- qnorm(alpha, mean = 0, sd = se)

# Distribuições sob H0 e H1
x <- seq(-0.5, 0.3, length.out = 1000)
h0 <- dnorm(x, mean = 0,    sd = se)
h1 <- dnorm(x, mean = delta, sd = se)
df <- data.frame(x = x, H0 = h0, H1 = h1)

# Gráfico (atribuir a 'p')
p <- ggplot(df, aes(x = x)) +
  geom_line(aes(y = H0), color = "black", linewidth = 1) +
  geom_line(aes(y = H1), color = "blue",  linewidth = 1) +
  # Erro tipo I (α) à esquerda sob H0
  stat_function(fun = dnorm, args = list(mean = 0, sd = se),
                geom = "area", fill = "red", alpha = 0.4,
                xlim = c(min(x), crit)) +
  # Erro tipo II (β) à direita do crit sob H1 (porque a região de aceitação está à direita do crit)
  stat_function(fun = dnorm, args = list(mean = delta, sd = se),
                geom = "area", fill = "orange", alpha = 0.4,
                xlim = c(crit, max(x))) +
  geom_vline(xintercept = crit, linetype = "dashed", color = "darkred") +
  annotate("text", x =  0.15, y = max(h0)*0.9, label = "H0: \u03BC = 0",    color = "black") +
  annotate("text", x = -0.30, y = max(h1)*0.9, label = "H1: \u03BC = -0.1", color = "blue") +
  annotate("text", x = -0.40, y = max(h0)*0.35, label = "Área vermelha — Erro Tipo I (α)",  color = "red") +
  annotate("text", x =  0.10, y = max(h0)*0.35, label = "Área laranja — Erro Tipo II (β)", color = "orange") +
  annotate("text", x = crit + 0.001, y = max(h0)*0.95,
           label = sprintf("limiar (crit) = %.3f", crit), hjust = -0.1, angle = 90) +
  labs(
    title = "Distribuições sob H0 e H1 (teste unilateral à esquerda)",
    subtitle = sprintf("n = %d, \u03B1 = 0.05, potência = 0.80, \u03B4 = %.3f, sd = %.3f", n, delta, sd),
    x = "Estatística (diferença média)", y = "Densidade"
  ) +
  theme_minimal()

# Salvar e embutir em base64
img_path <- tempfile(fileext = ".png")
ggsave(filename = img_path, plot = p, width = 7.5, height = 4.2, dpi = 130)
img_b64 <- dataURI(file = img_path, mime = "image/png")

# Exibir com legenda justificada
display_html(sprintf('
<div style="text-align:center; max-width:100%%;">
  <img src="%s" style="max-width:100%%; height:auto;">
  <div style="margin-top:12px; font-size:90%%; color:#555; text-align:justify; max-width:900px; margin:0 auto;">
    <b>Figura:</b> teste unilateral à esquerda para detectar redução de média. 
    As curvas mostram H0: \u03BC = 0 (preta) e H1: \u03BC = %.3f (azul), com desvio padrão amostral sd = %.3f e tamanho amostral n = %d.
    O limiar crítico (linha tracejada) é o quantil de cauda esquerda para \u03B1 = 0.05 sob H0, em escala da estatística (crit = %.3f).
    A área vermelha representa o erro tipo I (probabilidade de rejeitar H0 quando H0 é verdadeira).
    A área laranja representa o erro tipo II (probabilidade de não rejeitar H0 quando H1 é verdadeira), compatível com potência = 1 - \u03B2 = %.2f.
  </div>
</div>
', img_b64, delta, sd, n, crit, power))

# Pacotes
library(ggplot2)
library(gridExtra)
library(base64enc)
library(IRdisplay)

# Parâmetros gerais
gl    <- 24
alpha <- 0.05
t_obs <- 2.3
t_obs_esq <- -2.3
t_obs_bi  <- 2.3

# Sequência t
x <- seq(-4, 4, length.out = 1000)
df_t <- data.frame(x = x, y = dt(x, df = gl))

# Gráfico 1 — Unilateral à direita
t_crit_dir <- qt(1 - alpha, df = gl)
g1 <- ggplot(df_t, aes(x, y)) +
  geom_line(color = "black", linewidth = 1) +
  geom_area(data = subset(df_t, x > t_crit_dir), aes(x, y), fill = "red", alpha = 0.4) +
  geom_vline(xintercept = t_crit_dir, linetype = "dotted", color = "red") +
  geom_vline(xintercept = t_obs, linetype = "dashed", color = "blue") +
  labs(title = "Unilateral à direita (α = 0.05)", x = "t", y = "Densidade") +
  annotate("text", x = t_crit_dir + 0.3, y = 0.05, label = "t crítico", color = "red") +
  annotate("text", x = t_obs + 0.3, y = 0.10, label = "t observado", color = "blue") +
  theme_minimal()

# Gráfico 2 — Unilateral à esquerda
t_crit_esq <- qt(alpha, df = gl)
g2 <- ggplot(df_t, aes(x, y)) +
  geom_line(color = "black", linewidth = 1) +
  geom_area(data = subset(df_t, x < t_crit_esq), aes(x, y), fill = "red", alpha = 0.4) +
  geom_vline(xintercept = t_crit_esq, linetype = "dotted", color = "red") +
  geom_vline(xintercept = t_obs_esq, linetype = "dashed", color = "blue") +
  labs(title = "Unilateral à esquerda (α = 0.05)", x = "t", y = "Densidade") +
  annotate("text", x = t_crit_esq - 0.5, y = 0.05, label = "t crítico", color = "red") +
  annotate("text", x = t_obs_esq - 0.2, y = 0.10, label = "t observado", color = "blue") +
  theme_minimal()

# Gráfico 3 — Bicaudal
t_crit_bi <- qt(1 - alpha/2, df = gl)
g3 <- ggplot(df_t, aes(x, y)) +
  geom_line(color = "black", linewidth = 1) +
  geom_area(data = subset(df_t, x < -t_crit_bi), aes(x, y), fill = "red", alpha = 0.4) +
  geom_area(data = subset(df_t, x >  t_crit_bi), aes(x, y), fill = "red", alpha = 0.4) +
  geom_vline(xintercept = -t_crit_bi, linetype = "dotted", color = "red") +
  geom_vline(xintercept =  t_crit_bi, linetype = "dotted", color = "red") +
  geom_vline(xintercept = -t_obs_bi,  linetype = "dashed", color = "blue") +
  geom_vline(xintercept =  t_obs_bi,  linetype = "dashed", color = "blue") +
  labs(title = "Bicaudal (α/2 em cada cauda)", x = "t", y = "Densidade") +
  annotate("text", x = t_crit_bi + 0.3, y = 0.05, label = "± t crítico", color = "red") +
  annotate("text", x = t_obs_bi + 0.3,  y = 0.10, label = "± t observado", color = "blue") +
  theme_minimal()

# Combinar sem desenhar na tela
combined <- arrangeGrob(g1, g2, g3, ncol = 3)

# Salvar e embutir em base64
img_path <- tempfile(fileext = ".png")
ggsave(filename = img_path, plot = combined, width = 14, height = 5, dpi = 140)
img_b64 <- dataURI(file = img_path, mime = "image/png")

# Exibir com legenda justificada
display_html(sprintf('
<div style="text-align:center; max-width:100%%;">
  <img src="%s" style="max-width:100%%; height:auto;">
  <div style="margin-top:12px; font-size:90%%; color:#555; text-align:justify; max-width:1100px; margin:0 auto;">
    <b>Figura:</b> comparação entre três testes t com %d graus de liberdade: (i) unilateral à direita, (ii) unilateral à esquerda e (iii) bicaudal.
    As áreas vermelhas representam as regiões críticas para α = 0.05. Linhas azuis marcam os valores observados de t; linhas vermelhas pontilhadas marcam os críticos.
    O painel bicaudal reparte α/2 em cada cauda, enquanto os unilaterais concentram α apenas na cauda correspondente ao sinal da hipótese alternativa.
  </div>
</div>
', img_b64, gl))

# Pacotes
library(ggplot2)
library(base64enc)
library(IRdisplay)

# Dados
x <- seq(-4, 4, length.out = 1000)
y <- dnorm(x)
dfn <- data.frame(x, y)

alpha <- 0.05
z_alpha <- qnorm(1 - alpha)    # 1.645...
z_obs  <- 1.9
p_val  <- 1 - pnorm(z_obs)     # unilateral à direita

# Gráfico (atribuir a 'p')
p <- ggplot(dfn, aes(x = x, y = y)) +
  geom_line(color = "black") +
  geom_area(data = subset(dfn, x > z_alpha), fill = "red", alpha = 0.3) +
  geom_vline(xintercept = z_alpha, linetype = "dashed", color = "red") +
  geom_vline(xintercept = z_obs, linetype = "dotted", color = "blue", linewidth = 1) +
  labs(title = "Região de rejeição (unilateral, α = 0.05)", x = "z", y = "Densidade") +
  theme_minimal()

# Salvar e embutir em base64
img_path <- tempfile(fileext = ".png")
ggsave(filename = img_path, plot = p, width = 8, height = 5, dpi = 120)
img_b64 <- dataURI(file = img_path, mime = "image/png")

# Exibir com legenda justificada
display_html(sprintf('
<div style="text-align:center; max-width:100%%;">
  <img src="%s" style="max-width:100%%; height:auto;">
  <div style="margin-top:10px; font-size:90%%; color:#555; text-align:justify; max-width:820px; margin:0 auto;">
    <b>Figura:</b> teste unilateral à direita com α = 0.05. A área em vermelho indica a região de rejeição (z &gt; %.3f).
    A linha azul pontilhada marca o valor observado, z = %.2f, cujo valor-p unilateral é %.4f.
    Como z<sub>obs</sub> %s z<sub>crítico</sub>, %s H<sub>0</sub>.
  </div>
</div>
', img_b64, z_alpha, z_obs, p_val,
   if (z_obs > z_alpha) ">" else "<",
   if (z_obs > z_alpha) "rejeita-se" else "não se rejeita"))

# Pacotes
library(ggplot2)
library(base64enc)
library(IRdisplay)

# Parâmetros
p0 <- 0.04
p1 <- 0.06
n <- 400
alpha <- 0.05

# Erros padrão
ep0 <- sqrt(p0 * (1 - p0) / n)
ep1 <- sqrt(p1 * (1 - p1) / n)

# Crítico (unilateral à direita)
z_crit <- qnorm(1 - alpha)
p_crit <- p0 + z_crit * ep0

# Curvas sob H0 e H1
p_vals <- seq(0.02, 0.09, length.out = 1000)
h0 <- dnorm(p_vals, mean = p0, sd = ep0)
h1 <- dnorm(p_vals, mean = p1, sd = ep1)
df <- data.frame(p = p_vals, H0 = h0, H1 = h1)

# Métricas: β e potência
beta <- pnorm((p_crit - p1) / ep1)   # P_H1(p < p_crit)
power <- 1 - beta

# Gráfico (atribuir a 'p')
p <- ggplot(df, aes(x = p)) +
  geom_line(aes(y = H0), color = "black", linewidth = 1) +
  geom_line(aes(y = H1), color = "blue",  linewidth = 1) +
  geom_area(data = subset(df, p > p_crit), aes(y = H0),
            fill = "red",  alpha = 0.4) +          # α (tipo I)
  geom_area(data = subset(df, p < p_crit), aes(y = H1),
            fill = "orange", alpha = 0.3) +        # β (tipo II)
  geom_vline(xintercept = p0,    linetype = "dashed", color = "black") +
  geom_vline(xintercept = p1,    linetype = "dashed", color = "blue") +
  geom_vline(xintercept = p_crit,linetype = "dotted", color = "darkred") +
  labs(title = "Teste de Hipótese: Erros Tipo I (α) e II (β)",
       x = "Proporção amostral", y = "Densidade") +
  annotate("text", x = 0.026, y = max(h0)*0.9, label = "H[0](p)", parse = TRUE, color = "black") +
  annotate("text", x = 0.072, y = max(h1)*0.9, label = "H[1](p)", parse = TRUE, color = "blue") +
  annotate("text", x = p_crit + 0.001, y = max(h0)*0.75,
           label = sprintf("p_crit = %.4f", p_crit), hjust = 0, color = "darkred") +
  theme_minimal()

# Salvar e embutir em base64
img_path <- tempfile(fileext = ".png")
ggsave(filename = img_path, plot = p, width = 9, height = 5.2, dpi = 130)
img_b64 <- dataURI(file = img_path, mime = "image/png")

# Exibir com legenda justificada
display_html(sprintf('
<div style="text-align:center; max-width:100%%;">
  <img src="%s" style="max-width:100%%; height:auto;">
  <div style="margin-top:12px; font-size:90%%; color:#555; text-align:justify; max-width:900px; margin:0 auto;">
    <b>Figura:</b> teste unilateral à direita para proporções com n = %d. 
    Curvas: H<sub>0</sub>: p = %.2f (preta) e H<sub>1</sub>: p = %.2f (azul). 
    O limiar de decisão é p<sub>crit</sub> = %.4f (linha pontilhada vermelha). 
    A área vermelha representa o erro tipo I (α = %.2f), e a área laranja representa o erro tipo II (β = %.3f),
    resultando em potência = 1 − β = %.3f.
  </div>
</div>
', img_b64, n, p0, p1, p_crit, alpha, beta, power))

# Pacotes necessários
if (!require(ggplot2)) install.packages("ggplot2")
if (!require(gridExtra)) install.packages("gridExtra")
if (!require(base64enc)) install.packages("base64enc")
if (system.file(package = "IRdisplay") != "") {
  library(IRdisplay)
}

library(ggplot2)
library(gridExtra)
library(base64enc)

# Parâmetros fixos globais
delta <- 2.0
sigma <- 5.0
alpha <- 0.05

# Função para criar os gráficos sem plotar automaticamente
plot_power_analysis <- function(n, power, title) {
  z_alpha <- qnorm(1 - alpha)
  se <- sigma / sqrt(n)
  mu0 <- 0
  mu1 <- delta
  crit <- mu0 + z_alpha * se
  
  x <- seq(-5, 8, length.out = 2000)
  df <- data.frame(
    x = x,
    H0 = dnorm(x, mean = mu0, sd = se),
    H1 = dnorm(x, mean = mu1, sd = se)
  )
  
  alpha_df <- subset(df, x >= crit)
  beta_df <- subset(df, x < crit)
  
  alpha_val <- 1 - pnorm(crit, mean = mu0, sd = se)
  beta_val <- pnorm(crit, mean = mu1, sd = se)
  
  ggplot(df, aes(x)) +
    geom_line(aes(y = H0, color = "H0")) +
    geom_line(aes(y = H1, color = "H1")) +
    geom_area(data = alpha_df, aes(y = H0), fill = "blue", alpha = 0.3) +
    geom_area(data = beta_df, aes(y = H1), fill = "red", alpha = 0.3) +
    geom_vline(xintercept = crit, linetype = "dashed") +
    annotate("text", x = crit, y = max(df$H0)*0.9,
             label = sprintf("Ponto crítico = %.2f", crit),
             hjust = -0.1, vjust = 1, size = 3.5) +
    annotate("text", x = mu0 + 3.9*se, y = max(df$H0)/2,
             label = sprintf("α = %.3f", alpha_val),
             color = "blue", size = 4) +
    annotate("text", x = mu1 - 3.9*se, y = max(df$H1)/2,
             label = sprintf("β = %.3f", beta_val),
             color = "red", size = 4) +
    annotate("text", x = -4.5, y = 0.5,
             label = sprintf("H0: N(%.1f, %.2f²)", mu0, se),
             color = "blue", size = 4, hjust = 0) +
    annotate("text", x = 5, y = 0.3,
             label = sprintf("H1: N(%.1f, %.2f²)", mu1, se),
             color = "red", size = 4, hjust = 0) +
    labs(title = sprintf("%s (n=%d, Potência=%.0f%%)", title, n, power*100),
         y = "Densidade", x = "Diferença (Mbps)") +
    scale_color_manual(values = c("H0" = "blue", "H1" = "red")) +
    theme_minimal() +
    theme(legend.position = "bottom", legend.title = element_blank(),
          plot.margin = unit(c(1,1,1,1), "cm"))
}

# Cria os gráficos sem mostrar
p1 <- plot_power_analysis(54, 0.90, "Cenário 1")
p2 <- plot_power_analysis(68, 0.95, "Cenário 2")

# --- NOVO BLOCO: Renderiza e salva o gráfico de forma controlada ---
img_path <- tempfile(fileext = ".png")
png(img_path, width = 1200, height = 500, res = 100)
grid.arrange(p1, p2, ncol = 2) # Renderiza a combinação diretamente para o arquivo PNG
dev.off()

# Converte para base64 e remove o arquivo temporário
img_b64 <- base64enc::dataURI(file = img_path, mime = "image/png")
unlink(img_path)

# Cálculos para a legenda
delta <- 2.0
sigma <- 5.0
alpha <- 0.05
beta_n54 <- pnorm(qnorm(1 - alpha, mean = 0, sd = sigma/sqrt(54)), mean = delta, sd = sigma/sqrt(54))
beta_n68 <- pnorm(qnorm(1 - alpha, mean = 0, sd = sigma/sqrt(68)), mean = delta, sd = sigma/sqrt(68))
power_54 <- 1 - beta_n54
power_68 <- 1 - beta_n68

display_html(sprintf('
<div style="text-align:center; max-width:100%%;">
  <img src="%s" style="max-width:100%%; height:auto;">
  <div style="margin-top:12px; font-size:90%%; color:#555; text-align:justify; max-width:900px; margin:0 auto;">
    <b>Figura:</b> Esta análise de poder estatístico para um teste Z de uma cauda compara dois cenários com uma diferença real (δ) de %.1f Mbps, desvio padrão (σ) de %.1f Mbps e nível de significância (α) de %.2f. O cenário 1 (n=54) apresenta um erro tipo II (β) de %.3f, resultando em uma potência de %.3f. Já o cenário 2 (n=68), com um tamanho amostral maior, reduz o erro β para %.3f, elevando a potência para %.3f. O gráfico demonstra visualmente como o aumento do tamanho da amostra (n) diminui a área de β (vermelha) e, consequentemente, aumenta a potência do teste.
  </div>
</div>', 
img_b64, delta, sigma, alpha, beta_n54, power_54, beta_n68, power_68))

# Pacotes
library(ggplot2)
library(base64enc)
library(IRdisplay)

# Dados simulados
set.seed(42)
n <- 50
dados <- data.frame(
  latencia_ms = c(rnorm(n, 20, 2),  # UDP
                  rnorm(n, 24, 3)), # TCP
  protocolo = rep(c("UDP", "TCP"), each = n)
)

# Criar gráfico
p <- ggplot(dados, aes(x = protocolo, y = latencia_ms, fill = protocolo)) +
  geom_boxplot() +
  scale_fill_brewer(palette = "Pastel1") +
  labs(title = "Latência UDP vs TCP", 
       x = "Protocolo", 
       y = "Latência (ms)") +
  theme_minimal()

# Estatísticas descritivas
estatisticas <- aggregate(latencia_ms ~ protocolo, dados, 
                          FUN = function(x) c(mediana = median(x), 
                                           iqr = IQR(x)))

# Salvar e embutir
img_path <- tempfile(fileext = ".png")
ggsave(img_path, p, width = 7, height = 5)
img_b64 <- base64enc::dataURI(file = img_path, mime = "image/png")

# Exibir com legenda
display_html(sprintf('
<div style="text-align:center; max-width:800px; margin:0 auto;">
  <img src="%s" style="max-width:100%%; height:auto;">
  <div style="margin-top:10px; color:#555; text-align:justify;">
    <b>Figura:</b> comparação de latência entre protocolos (n=%d por grupo).
    Mediana UDP = %.1f ms (IQR = %.1f ms) vs TCP = %.1f ms (IQR = %.1f ms).
    Boxplots mostram quartis, com bigodes de 1.5×IQR e pontos para outliers.
  </div>
</div>', 
img_b64, n,
estatisticas[1,2][1], estatisticas[1,2][2],  # UDP: mediana e IQR
estatisticas[2,2][1], estatisticas[2,2][2])) # TCP: mediana e IQR

library(ggplot2)
library(tidyr)
x <- seq(-4, 4, length.out = 1000)
df <- data.frame(
  x = x,
  dnorm = dnorm(x)
)

# Limiares para diferentes níveis de significância
limiares <- data.frame(
  alpha = c(0.10, 0.05, 0.01),
  zcrit = qnorm(1 - c(0.10, 0.05, 0.01)),
  cor = c("orange", "blue", "red")
)

ggplot(df, aes(x, dnorm)) +
  geom_line(size = 1.2) +
  geom_area(data = subset(df, x > limiares$zcrit[1]), fill = limiares$cor[1], alpha = 0.3) +
  geom_area(data = subset(df, x > limiares$zcrit[2]), fill = limiares$cor[2], alpha = 0.3) +
  geom_area(data = subset(df, x > limiares$zcrit[3]), fill = limiares$cor[3], alpha = 0.3) +
  geom_vline(xintercept = 2.1, linetype = "dashed", color = "black") +
  labs(title = "Rejeição da Hipótese nula para diferentes níveis de significância",
       subtitle = "Linha preta: z observado = 2.1",
       x = "z", y = "densidade") +
  theme_minimal()

n <- c(10, 20, 50, 100) 
margem_erro <- 1.96 * 8 / sqrt(n)
plot(n, margem_erro, type = "b", col = "blue", ylab = "Margem de erro", xlab = "Tamanho da amostra")

N7	N2	P
0	0	$0.5 \cdot 0.5= 0.0025$
0	1	$0.5 \cdot 0.95=0.0475$
1	0	$0.95\cdot0.5=0.0475$
1	1	$0.95\cdot0.95=0.9025$

R1	R2	R3	Probabilidade
0	0	0	0,9 × 0,85 × 0,95 = 0,72675
0	0	1	0,9 × 0,85 × 0,05 = 0,03825
0	1	0	0,9 × 0,15 × 0,95 = 0,12825
0	1	1	0,9 × 0,15 × 0,05 = 0,00675
1	0	0	0,1 × 0,85 × 0,95 = 0,08075
1	0	1	0,1 × 0,85 × 0,05 = 0,00425
1	1	0	0,1 × 0,15 × 0,95 = 0,01425
1	1	1	0,1 × 0,15 × 0,05 = 0,00075

Perdidos	Retransmitidos	$P(\text{marg}) \cdot P(\text{cond})$	$P(\text{total})$
0	0	$0.99 \cdot 0.95$	$0.9405$
0	1	$0.99 \cdot 0.05$	$0.0495$
1	0	$0.01 \cdot 0.05$	$0.0005$
1	1	$0.01 \cdot 0.95$	$0.0095$

Ataque (A)	Alerta (L)	Probabilidade Conjunta
0	0	0.99 × 0.96 = 0.9504
0	1	0.99 × 0.04 = 0.0396
1	0	0.01 × 0.02 = 0.0002
1	1	0.01 × 0.98 = 0.0098

A_disp	B_disp	$P(\text{marg}) \cdot P(\text{cond})$	$P(\text{conj.})$
0	0	$P(\bar{A}) \cdot P(\bar{B} \mid \bar{A})$	$0.01$
0	1	$P(\bar{A}) \cdot P(B \mid \bar{A})$	$0.09$
1	0	$P(A) \cdot P(\bar{B} \mid A)$	$0.09$
1	1	$P(A) \cdot P(B \mid A)$	$0.81$

Linha	Classe	A	B	P(Classe)	$P(\text{marg}) \cdot P(\text{cond})$	P(Conjunta)
1	0	0	0	0.5	0.85 * 0.9	0.3825
2	0	0	1	0.5	0.85 * 0.1	0.0425
3	0	1	0	0.5	0.15 * 0.9	0.0675
4	0	1	1	0.5	0.15 * 0.1	0.0075
5	1	0	0	0.5	0.15 * 0.1	0.0075
6	1	0	1	0.5	0.15 * 0.9	0.0675
7	1	1	0	0.5	0.85 * 0.1	0.0425
8	1	1	1	0.5	0.85 * 0.9	0.3825

A	B	$P(\text{marg}) \cdot P(\text{marg})$	$P(\text{conj.})$
0	0	$P(\bar{A}) \cdot P(\bar{B})$	$0.0001$
0	1	$P(\bar{A}) \cdot P(B)$	$0.0099$
1	0	$P(A) \cdot P(\bar{B})$	$0.0099$
1	1	$P(A) \cdot P(B)$	$0.9801$

Ataque ($At$)	Alerta ($Al$)	$P(\text{marg}) \cdot P(\text{cond})$	$P(\text{conj})$
0	0	$0.85 \cdot 0.95$	$0.8075$
0	1	$0.85 \cdot 0.05$	$0.0425$
1	0	$0.15 \cdot 0.10$	$0.015$
1	1	$0.15 \cdot 0.90$	$0.135$

Expressão	Significado
$C = 1$	Evento: “o usuário é legítimo”
$P(C = 1)$	Probabilidade de o usuário ser legítimo
$C$	A variável aleatória (sem valor fixado ainda)

Situação	Teste recomendado
Pareado, normal	t pareado
Pareado, não normal	Wilcoxon pareado
Independente, normal, variâncias iguais	t (Student)
Independente, normal, variâncias diferentes	t de Welch
Independenten, não normal, $n < 30$	Mann–Whitney
Variâncias conhecidas, $n \geq 30$	Z

$n$	$\sqrt{n}$	$1/\sqrt{n}$	Erro Padrão
5	2.2361	0.4472	4.4721
10	3.1623	0.3162	3.1623
15	3.8730	0.2582	2.5820
20	4.4721	0.2236	2.2361
25	5.0000	0.2000	2.0000
30	5.4772	0.1826	1.8257
35	5.9161	0.1690	1.6903
40	6.3246	0.1581	1.5811
45	6.7082	0.1491	1.4907
50	7.0711	0.1414	1.4142

Situação Real	Decisão Tomada	Resultado Estatístico	Nome Técnico	Probabilidade
$H_0$ é verdadeira	Rejeita $H_0$	Erro Tipo I	Falso Positivo	$\alpha$
$H_0$ é verdadeira	Não rejeita $H_0$	Decisão correta	Verdadeiro Negativo	$1 - \alpha$
$H_1$ é verdadeira	Rejeita $H_0$	Decisão correta	Verdadeiro Positivo	$1 - \beta$
$H_1$ é verdadeira	Não rejeita $H_0$	Erro Tipo II	Falso Negativo	$\beta$

Suspeito	Malicioso	P(conj.)
0	0	0.784
0	1	0.016
1	0	0.080
1	1	0.120

Urgente ($U$)	Atraso ($A$)	$P(U, A)$
0	0	0.595
0	1	0.105
1	0	0.276
1	1	0.024

$n$	$\bar{x}$ (ms)	$s$ (ms)
10	14.5	2.3
30	14.9	2.0
100	15.1	1.7

Exercício 1¶

Exercício 2¶

Exercício 4¶

Bloco 2 – Portas e protocolos¶

Exercício 5¶

exercicio 6¶

Exercício 7¶

Exercício 8¶

Bloco 3 – Pacotes e interfaces¶

Exercício 9¶

Exercício 10¶

Exercício 11¶

Exercício 12¶

Bloco 4 – MAC e ARP¶

Exercício 13¶

Exercício 14¶

Exercício 15¶

Bloco 5 – Protocolo e conteúdo de pacotes¶

Exercício 16¶

Exercício 17¶

Exercício 18¶

Bloco 6 – Combinatórias simples em redes¶

Exercício 19¶

Exercício 20¶

Exercício 21¶

Exercício 22¶

Bloco 8 – Eventos binários em redes¶

Exercício 26¶

Exercício 27¶

Exercício 28¶

Bloco 7 – DNS, HTTP e protocolos de aplicação¶

Exercício 23¶

Exercício 24¶

Exercício 25¶

Bloco 9 – Fragmentação e retransmissão¶

Exercício 29¶

Exercício 30¶

Fase 2 – Bloco 1: Eventos como Subconjuntos (continuação)¶

Exercício 31¶

Exercício 32¶

Exercício 33¶

Exercício 34¶

Exercício 35¶

Exercício 36¶

Exercício 37¶

Exercício 38¶

Exercício 39¶

Exercício 39b¶

Fase 2 – Bloco 1: Eventos como Subconjuntos (continuação)¶

Fase 3 – Bloco 1: Variável Aleatória Discreta¶

Exercício 62¶

Exercício 63¶

Exercícios 64–65¶

Exercício 66/67¶

Exercício 68¶

Exercícios 69/70¶

Exercícios 71/72¶

Exercício 73¶

Exercícios 74/75¶

Exercício 76/77¶

Exercício 81¶

Exercícios 82/83/84¶

Exercício 85¶

Exercício 86¶

Exercício 87/88¶

Exercício 89¶

Exercício 91¶

Exercício 92¶

Exercício 93¶

Exercício 94¶

Exercício 95¶

Exercício 96.¶

Exercício 97/98¶

Exercício 99¶

Exercício 100¶

Exercício 101¶

Exercício 102¶

Exercício 103¶

Exercício 104¶

Exercício 105¶