Este documento descreve um estudo que compara algoritmos quadráticos e loglineares através de métodos de Monte Carlo e bootstrap. Ele define funções para estimadores, cálculo de erro quadrático médio, e simulações de Monte Carlo com e sem loops explícitos. O documento gera amostras bootstrap variando o parâmetro B, armazena os dados em um data frame, e produz gráficos comparando os resultados dos diferentes estimadores.

1. File: /media/SAMSUNG/10-CoursesAndD…011]/00.bootstrap.evaluation.r
#-----------------------------------------------------------------------------# About : Exemplo de comparação entre algoritmos quadráticos e loglineares
# Author : Michel A. dos Santos, Maria Helynne e Ana Carla
# Date
: 30/05/2011 - Maio - 2011
#-----------------------------------------------------------------------------#-----------------------------------------------------------------------------# Carregamento das bibliotecas necessárias para processamento do script
#-----------------------------------------------------------------------------# Definindo o nome das bibliotecas que devem ser carregadas
pkg = c('lattice')
# Carregando bibliotecas
print('Carregando bibliotecas necessárias para execução do script...')
for (idx_pkg in 1:length(pkg))
{
myimg.msgerr <- paste('A seguinte biblioteca não pôde ser carregada: ', pkg[idx_pkg])
if (!require(pkg[idx_pkg], character.only = TRUE)) stop(myimg.msgerr)
}
#-----------------------------------------------------------------------------# Configurações iniciais do script e inicialização de variáveis:
#-----------------------------------------------------------------------------#-----------------------------------------------------------------------------# Variável de configuração que verifica se os gráficos devem ser salvos
#-----------------------------------------------------------------------------my.save.result <- TRUE
#-----------------------------------------------------------------------------# Variável de configuração que verifica se o dataframe deve ser salvo
#-----------------------------------------------------------------------------my.data.frame.save.result <- TRUE
#-----------------------------------------------------------------------------# Variável de configuração que verifica se os resultados devem ser vistos
# através de uma grade.
#-----------------------------------------------------------------------------my.view.grid.results <- FALSE
#-----------------------------------------------------------------------------# Variáveis de controle do problema (variáveis globais)
#------------------------------------------------------------------------------
Page 1 of 10

2. File: /media/SAMSUNG/10-CoursesAndD…011]/00.bootstrap.evaluation.r
valor1
valor2
valormv
<- 0
<- 0
<- 0
# Método por analogia | Primeiro momento amostral
# Método por analogia | Segundo momento amostral
# Máxima verossimilhança
#-----------------------------------------------------------------------------# Definição das funções e estruturas implementadas para o problema.
#-----------------------------------------------------------------------------# Estimador - Teta 1 - Primeiro momento amostral
MyU_T1 <- function(X) { return ( 2*mean(X) ) }
# Estimador - Teta 2 - Segundo momento amostral
MyU_T2 <- function(X) { return (sqrt(3*mean(X^2))) }
# Estimador - Máxima Verossimilhança
MyU_TMV <- function(X) { return ( max(X) ) }
# Definição da função que calcula o erro quadrático médio (MSE)
MyMeanSquaredError <- function(X) { return( (mean(X)-1)^2 + var(X) ) }
# Bootstrap sem o uso de looping de maneira explícita
NotExplicitlyIterativeBootstrap <- function(X, B, func)
{
t <- func(X)
t_bs <- 2*t - mean(unlist(lapply(1:B, function(i) i<- func(sample(X,replace=TRUE)))))
return (t_bs)
}
# Montecarlo sem o uso explicito de looping
NotExplicitlyIterativeMontecarlo <- function(number.of.observations = 10,
number.of.bootstrap.iterations = 200,
length.of.my.vector = 100)
{
n
<- number.of.observations
# Número de observações em runif
MyNobi <- number.of.bootstrap.iterations # Número de iterações no bootstrap
MyLen <- length.of.my.vector
# Tamanho do vetor de estimadores
# Criando vetores numéricos
e1 <- e2 <- emv <- e1B <- e2B <- emvB <- vector(mode="numeric",length=MyLen)
lapply(1:MyLen, function(r){ X <-runif(n)
e1[r]
<<- MyU_T1(X)
Page 2 of 10

3. File: /media/SAMSUNG/10-CoursesAndD…011]/00.bootstrap.evaluation.r
e2[r]
emv[r]
e1B[r]
e2B[r]
emvB[r]
})
<<<<<<<<<<-
MyU_T2(X)
MyU_TMV(X)
NotExplicitlyIterativeBootstrap(X, MyNobi, MyU_T1)
NotExplicitlyIterativeBootstrap(X, MyNobi, MyU_T2)
NotExplicitlyIterativeBootstrap(X, MyNobi, MyU_TMV)
valor1 <<- ( 1 - (MyMeanSquaredError(e1B) / MyMeanSquaredError(e1)) )*100
valor2 <<- ( 1 - (MyMeanSquaredError(e2B) / MyMeanSquaredError(e2)) )*100
valormv <<- ( 1 - (MyMeanSquaredError(emvB) / MyMeanSquaredError(emv)))*100
}
# Bootstrap com uso de looping de maneira explícita
ExplicitlyIterativeBootstrap <- function(X, B, func)
{
t <- func(X)
vecB <- vector(mode="numeric",length=B)
for (b in 1:B) vecB[b] <- func(sample(X,replace=TRUE))
t_bs <- 2*t - mean(vecB)
return (t_bs)
}
# Montecarlo com uso explicito de looping
ExplicitlyIterativeMontecarlo <- function(number.of.observations = 10,
number.of.bootstrap.iterations = 200,
length.of.my.vector = 100)
{
n
<- number.of.observations
# Número de observações em runif
MyNobi <- number.of.bootstrap.iterations # Número de iterações no bootstrap
MyLen <- length.of.my.vector
# Tamanho do vetor de estimadores
e1 <- e2 <- emv <- e1B <- e2B <- emvB <- vector(mode="numeric",length=MyLen)
for (r in 1:MyLen)
{
X <- runif(n)
e1[r]
<- MyU_T1(X)
e2[r]
<- MyU_T2(X)
emv[r] <- MyU_TMV(X)
Page 3 of 10

4. File: /media/SAMSUNG/10-CoursesAndD…011]/00.bootstrap.evaluation.r
Page 4 of 10
e1B[r] <- ExplicitlyIterativeBootstrap(X, MyNobi, MyU_T1)
e2B[r] <- ExplicitlyIterativeBootstrap(X, MyNobi, MyU_T2)
emvB[r] <- ExplicitlyIterativeBootstrap(X, MyNobi, MyU_TMV)
}
MyMeanSquaredError(e1)
MyMeanSquaredError(e2)
MyMeanSquaredError(emv)
MyMeanSquaredError(e1B)
MyMeanSquaredError(e2B)
MyMeanSquaredError(emvB)
}
#++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
# MAIN - Começo da execução do código.
#++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
# Capturando o tempo de inicio da atividade.
MyStartTime = Sys.time()
# Executando método montecarlo para um determinado número N
print("Executando Montecarlo explicitamente iterativo...")
my.number.of.observations
<- 100
my.number.of.bootstrap.iterations <- 200
my.length.of.my.vector
<- 100
ExplicitlyIterativeMontecarlo(my.number.of.observations, my.number.of.bootstrap.iterations, my.length.of.my.vector)
# Capturando o tempo de término das atividade.
MyEndTime = Sys.time()
# Visualizando o tempo para processamento do método
MyMatrixTime <- matrix(c("MyStartTime",MyStartTime, "MyEndTime", MyEndTime, "Total Time:", MyEndTime - MyStartTime),
ncol=2, byrow=TRUE)
print(MyMatrixTime)
if (my.view.grid.results) View( MyMatrixTime, title="Processing Time for Explicit Iterative Montecarlo" )
# Capturando o tempo de inicio da atividade.
MyStartTime = Sys.time()
# Executando método montecarlo para um determinado número N
print("Executando Montecarlo não explicitamente iterativo...")

5. File: /media/SAMSUNG/10-CoursesAndD…011]/00.bootstrap.evaluation.r
Page 5 of 10
my.number.of.observations
<- 100
my.number.of.bootstrap.iterations <- 200
my.length.of.my.vector
<- 100
NotExplicitlyIterativeMontecarlo(my.number.of.observations, my.number.of.bootstrap.iterations, my.length.of.my.vecto
r)
# Capturando o tempo de término das atividade.
MyEndTime = Sys.time()
# Visualizando o tempo para processamento do método
MyMatrixTime <- matrix(c("MyStartTime",MyStartTime, "MyEndTime", MyEndTime, "Total Time:", MyEndTime - MyStartTime),
ncol=2, byrow=TRUE)
print(MyMatrixTime)
if (my.view.grid.results) View( MyMatrixTime, title="Processing Time for Not Explicit Iterative Montecarlo" )
#-----------------------------------------------------------------------------# Produção de amostras obtidas através do método bootstrap. A partir daqui
# iremos armazenar o data.frame referente as amostras obtidas através do método
# bootstrap e os gráficos gerados a partir do montante de dados final.
#-----------------------------------------------------------------------------# Estipulando vetor de comparações utilizado no bootstrap
my.start.of.sequence <- 3
# Valor inicial do número de iterações
my.end.of.sequence
<- 100
# Parâmetro final de iterações B do bootstrap
my.jump.of.sequence <- 5
# Valor do salto dado dentro da seqüência
MyB = c(seq(my.start.of.sequence, my.end.of.sequence, my.jump.of.sequence))
# Exibindo informações relativas ao parâmetro B
print("")
print("Exibindo informações relativas ao parâmetro B")
print(paste("Início do intervalo de avaliação:", my.start.of.sequence))
print(paste("Fim do intervalo de avaliação:", my.end.of.sequence))
print(paste("Incremento do intervalo de avaliação:", my.jump.of.sequence))
print("")
# Exeutando o método montecarlo pela primeira vez
print("Obtendo os B valores necessários para efetivação do método...")
print(paste("Avaliação com B igual a:", my.start.of.sequence))
NotExplicitlyIterativeMontecarlo(my.number.of.observations, my.start.of.sequence, my.length.of.my.vector)
# Amostras para os dados processados transformadas em vetores
pE1 = c(valor1)

6. File: /media/SAMSUNG/10-CoursesAndD…011]/00.bootstrap.evaluation.r
Page 6 of 10
pE2 = c(valor2)
pE3 = c(valormv)
# Executando Montecarlo tomando por base os valores de uma sequência.
for (i in seq(my.start.of.sequence + my.jump.of.sequence, my.end.of.sequence, my.jump.of.sequence))
{
print(paste("Avaliação com B igual a:", i))
NotExplicitlyIterativeMontecarlo(my.number.of.observations, i, my.length.of.my.vector)
pE1 = c(pE1, valor1)
pE2 = c(pE2, valor2)
pE3 = c(pE3, valormv)
}
# Criando um dataframe com os dados adquiridos
my.data.frame <- data.frame(MyB, pE1, pE2, pE3)
# Exibindo valores do dataframe
print(my.data.frame)
if (my.view.grid.results) View(my.data.frame, title="Valores Adquiridos - Usando Montecarlo")
#-----------------------------------------------------------------------------# Inicio da plotagem
#-----------------------------------------------------------------------------#-----------------------------------------------------------------------------# Iniciando dispositivo de saída caso os resultados devam ser salvos em disco
#-----------------------------------------------------------------------------if (my.save.result)
{
save.name <- paste('saved.result.01[',my.end.of.sequence,'].pdf', sep='')
pdf(file = save.name, onefile = TRUE)
}
# PLOT CONFIG
my.col
<- 'black'
my.type
<- c("p","r")
my.pch
<- 20
my.scales <- list(x = list( relation = "free", limits = c(1, my.end.of.sequence*1.5)), y = list( relation = "free",
limits = c(-50, 50)))
my.xlab
<- "B"
my.ylab
<- expression(paste('Estimativa bootstrap do erro quadrático médio para o estimador ', theta[1]))

7. File: /media/SAMSUNG/10-CoursesAndD…011]/00.bootstrap.evaluation.r
Page 7 of 10
# PLOT
myplot01 <- xyplot(pE1~MyB, col = my.col, type = my.type, data = my.data.frame,
scales = my.scales, xlab = my.xlab, ylab = my.ylab, pch=my.pch)
if (!my.save.result) x11()
print(myplot01)
#-----------------------------------------------------------------------------# Encerrando dispositivo de saída caso os resultados devam ser salvos em disco
#-----------------------------------------------------------------------------if (my.save.result) { dev.off() }
#-----------------------------------------------------------------------------# Iniciando dispositivo de saída caso os resultados devam ser salvos em disco
#-----------------------------------------------------------------------------if (my.save.result)
{
save.name <- paste('saved.result.02[',my.end.of.sequence,'].pdf', sep='')
pdf(file = save.name, onefile = TRUE)
}
# PLOT CONFIG
my.col
<- 'red'
my.type
<- c("p","r")
my.pch
<- 20
my.scales <- list(x = list( relation = "free", limits = c(1, my.end.of.sequence*1.5)), y = list( relation = "free",
limits = c(-50, 50)))
my.xlab
<- "B"
my.ylab
<- expression(paste('Estimativa bootstrap do erro quadrático médio para o estimador ', theta[2]))
# PLOT
myplot02 <- xyplot(pE2~MyB, col = my.col, type = my.type, data = my.data.frame,
scales = my.scales, xlab = my.xlab, ylab = my.ylab, pch=my.pch)
if (!my.save.result) x11()
print(myplot02)
#-----------------------------------------------------------------------------# Encerrando dispositivo de saída caso os resultados devam ser salvos em disco
#-----------------------------------------------------------------------------if (my.save.result) { dev.off() }

8. File: /media/SAMSUNG/10-CoursesAndD…011]/00.bootstrap.evaluation.r
Page 8 of 10
#-----------------------------------------------------------------------------# Iniciando dispositivo de saída caso os resultados devam ser salvos em disco
#-----------------------------------------------------------------------------if (my.save.result)
{
save.name <- paste('saved.result.03[',my.end.of.sequence,'].pdf', sep='')
pdf(file = save.name, onefile = TRUE)
}
# PLOT CONFIG
my.col
<- 'green'
my.type
<- c("p","r")
my.pch
<- 20
my.scales <- list(x = list( relation = "free", limits = c(1, my.end.of.sequence*1.5)), y = list( relation = "free",
limits = c(-50, 50)))
my.xlab
<- "B"
my.ylab
<- expression(paste('Estimativa bootstrap do erro quadrático médio para o estimador ', theta[mv]))
# PLOT
myplot03 <- xyplot(pE3~MyB, col = my.col, type = my.type, data = my.data.frame,
scales = my.scales, xlab = my.xlab, ylab = my.ylab, pch=my.pch)
if (!my.save.result) x11()
print(myplot03)
#-----------------------------------------------------------------------------# Encerrando dispositivo de saída caso os resultados devam ser salvos em disco
#-----------------------------------------------------------------------------if (my.save.result) { dev.off() }
#-----------------------------------------------------------------------------# Abrindo uma nova janela no X para que não ocorra sobreposição das demais
#-----------------------------------------------------------------------------if (!my.save.result) x11(title="Confrontando as Estimativas Obtidas")
#-----------------------------------------------------------------------------# Iniciando dispositivo de saída caso os resultados devam ser salvos em disco
#-----------------------------------------------------------------------------if (my.save.result)
{
save.name <- paste('saved.result.04[',my.end.of.sequence,'].pdf', sep='')
pdf(file = save.name, onefile = TRUE)

9. File: /media/SAMSUNG/10-CoursesAndD…011]/00.bootstrap.evaluation.r
Page 9 of 10
}
# PLOT CONFIG
my.col
<- 'black'
my.ylab
<- expression(paste('Estimativa para ', theta[1]))
# PLOT
myplot01 <- xyplot(pE1~MyB, col = my.col, type = my.type, data = my.data.frame,
scales = my.scales, xlab = my.xlab, ylab = my.ylab, pch=my.pch)
# PLOT CONFIG
my.col
<- 'red'
my.ylab
<- expression(paste('Estimativa para ', theta[2]))
# PLOT
myplot02 <- xyplot(pE2~MyB, col = my.col, type = my.type, data = my.data.frame,
scales = my.scales, xlab = my.xlab, ylab = my.ylab, pch=my.pch)
# PLOT CONFIG
my.col
<- 'green'
my.ylab
<- expression(paste('Estimativa para ', theta[mv]))
# PLOT
myplot03 <- xyplot(pE3~MyB, col = my.col, type = my.type, data = my.data.frame,
scales = my.scales, xlab = my.xlab, ylab = my.ylab, pch=my.pch)
#PLOT
print(myplot01, position=c(0.1,0.1,1,1),split=c(1,1,2,2),more=T)
print(myplot02, position=c(0.1,0.1,1,1),split=c(1,2,2,2),more=T)
print(myplot03, position=c(0.1,0.1,1,1),split=c(2,1,2,2),more=F)
#-----------------------------------------------------------------------------# Encerrando dispositivo de saída caso os resultados devam ser salvos em disco
#-----------------------------------------------------------------------------if (my.save.result) { dev.off() }
#-----------------------------------------------------------------------------# Escrevendo os dados obtidos em disco
#-----------------------------------------------------------------------------if (my.data.frame.save.result)
{
my.file.name <- paste('Dados.Gerados.Em.',format(Sys.time(), "[Data.%F][Hora.%H.%M.%S]."),'[B.',my.start.of.sequen
ce,'.',my.end.of.sequence,'.',my.jump.of.sequence,']','.txt', sep='')
write.table(my.data.frame, file=my.file.name)

10. File: /media/SAMSUNG/10-CoursesAndD…011]/00.bootstrap.evaluation.r
}
#-----------------------------------------------------------------------------# Exibindo mensagem de finalização do script
#-----------------------------------------------------------------------------print('Fim do script ............ [OK]')
Page 10 of 10