#EJERCICIOS ESTUDIO

#Libro: Análisis Estadístico con R

#TEORÍA DE COLAS
#EJERCICIO 1

#M/M/1

#Un departamento de informática tiene que planificar la compra de un servidor que

le
#permita atender adecuadamente los programas de los estadísticos. Después de
realizar
#las monitorizaciones pertinentes, ve que tiene una media de 10 peticiones por
segundo.
#El tiempo medio que cada modelo estadístico tarda en computarse es de 0,083
segundos.
#Determine:
#Número promedio de clientes en el sistema
#Número promedio de clientes en la cola
#Tiempo de espera promedio en el sistema
#Tiempo de espera promedio en la cola

Library(queueing)

lambda<-10 #(peticiones/segundo)
mu<- 12 #(1/0.083)

#NOTA. n: número de clientes en el sistema. Si se pone n = 0, se calcula

#la probabilidad de que el servidor esté ocioso; con valor -1 no se
#calculan probabilidades.

servidor<- NewInput.MM1(lambda,mu,0)
CheckInput(servidor) #No muestra ningún error, se procede a construir el modelo
summary(QueueingModel(servidor))

#Número de clientes en el sistema (L) = 5

#Número de clientes en la cola (Lq) = 4.1666667
#Tiempo promedio de espera en el sistema (W) = 0.5
#Tiempo promedio de espera en la cola (Wq) = 0.4166667

#EJERCICIO 2
#https://rpubs.com/map0logo/sim02beta
#El Security & Trust Bank tiene 4 cajeros para atender a sus clientes, los cuales
#llegan según un proceso de Poisson con tasa media de 2 por minuto.El tiempo de
#transacciones entre el cajero y el cliente tiene distribución exponencial con
#media de 1 minuto.
#La gerencia ha establecido las siguientes políticas para lograr un nivel de
servicio
#satisfactorio. El número promedio de clientes que esperan en la cola para iniciar
su
#servicio no debe exceder de 1 (L<1). Al menos 95% del tiempo, el número de
clientes
#en la cola no debe exceder de 5 (Lq<5). En el caso de al menos 95% de los
clientes,
#el tiempo de espera para iniciar el servicio no debe exceder de 5 minutos (W<5).
#Determine si se cumplen estas políticas.

library(simmer)
library(simmer.plot)
library(parallel)
library(knitr)
library(dplyr)

set.seed(12345678)

lambda <- 2
mu <- 1

cliente <- trajectory() %>%

seize("cajero", amount=1) %>%
timeout(function() rexp(1, mu)) %>%
release("cajero", amount=1)

env <- simmer() %>%

add_resource("cajero", capacity=4, queue_size=Inf) %>%
add_generator("cliente", cliente, function() rexp(1, lambda)) %>%
run(until=480) # Jornada de 8 horas

#Intervalos de confianza (para replicar n cantidad de veces)

envs <- mclapply(1:100, function(i) {
simmer() %>%
add_resource("cajero", capacity=4, queue_size=Inf) %>%
add_generator("cliente", cliente, function() rexp(1, lambda1)) %>%
run(until=480) %>%
wrap()})

envs.arrivals <- get_mon_arrivals(env)

envs.resources <- get_mon_resources(env)
kable(head(envs.arrivals))
kable(head(envs.resources))

# Número promedio de clientes en el sistema - L -

n_system <- function(time, system){
sum(diff(time) * system[1:(length(time)-1)]) / time[length(time)]
}

# Número promedio de clientes en la cola - Lq -

n_queue <- function(time, queue){
sum(diff(time) * queue[1:(length(time)-1)]) / time[length(time)]
}

# Fracción del tiempo que hay n o menos en la cola

t_queue_le_n <- function(time, queue, n){
sum(diff(time) * (queue[1:(length(time)-1)] <= n)) / time[length(time)]
}

envs.n <- envs.resources %>%

group_by(replication) %>%
summarise(L = n_system(time, system),
Lq = n_queue(time, queue),
"t(Lq<5)" = t_queue_le_n(time, queue, 5))
kable(head(envs.n))

#Intervalos de confianza (no aplica si no se hacen las réplicas)

L.interval <- quantile(envs.n$L, c(.05, .95))
Lq.interval <- quantile(envs.n$Lq, c(.05, .95))
tLq5.interval <- quantile(envs.n$`t(Lq<5)`, c(.05, .95))
# Tiempo promedio en el sistema
w <- function(start_time, end_time){
mean(end_time - start_time)
}

# Tiempo promedio en la cola

wq <- function(start_time, end_time, activity_time){
mean(end_time - start_time - activity_time)
}

# Tiempo promedio en la cola

n_queue_le_t <- function(start_time, end_time, activity_time){
mean((end_time - start_time - activity_time) < 5)
}

envs.w <- envs.arrivals %>%

filter(finished == TRUE) %>% # Considerar solamente los que han salido del
sistema
group_by(replication) %>%
summarise(W = w(start_time, end_time),
Wq = wq(start_time, end_time, activity_time),
max_Wq = max(end_time - start_time - activity_time),
"n(Wq < 5)" = n_queue_le_t(start_time, end_time, activity_time))
kable(head(envs.w))

#Intervalos de confianza (no aplica si no se hacen las réplicas)

W.interval <- quantile(envs.w$W, c(.05, .95))
Wq.interval <- quantile(envs.w$Wq, c(.05, .95))

plot(envs.resources, metric="usage", "cajero", items="system", steps=TRUE)

plot(envs.arrivals, metric = "waiting_time", "clientes", items="system",
steps=TRUE)

#EJERCICIO 3
#Libro: Investigación de Operaciones Hillier-Liberman (pág. 760)
#El Midtown Bank siempre tiene dos cajeras en servicio. Los
#clientes llegan a las cajas a una tasa media de 40 por hora. Una cajera
#requiere en promedio 2 minutos para servir a un cliente. Cuando
#ambas cajeras están ocupadas, el cliente que llega se une a una cola
#y espera a que lo atiendan. Por experiencia se sabe que los clientes
#esperan en la cola un promedio de 1 minuto antes de pasar a la caja.
#Determine las medidas de desempeño básicas: Wq, W, L y Lq de
#este sistema. Use distribuciones exponenciales.

set.seed(12345)

l<-40 #(clientes/hr)
m<-30 #(por hora)
Wq<-1/60

nombre<-trajectory() %>%
seize("cajera", amount=1) %>%
timeout(function() rexp(1,m)) %>%
release("cajera",amount = 1)

simul.env<-simmer() %>%
add_resource("cajera", capacity=2, queue_size=Inf) %>%
add_generator("nombre",nombre, function() rexp(1, l)) %>%
 run(until = 8)

recursos<-get_mon_resources(simul.env)
llegadas<-get_mon_arrivals(simul.env)

kable(get_mon_resources(simul.env))
kable(get_mon_arrivals(simul.env))

plot(get_mon_resources(simul.env), metric = "usage", "cajera", items="system",

steps=TRUE)
plot(get_mon_arrivals(simul.env), metric = "waiting_time","clientes",
items="system", steps=TRUE)

# Número promedio de clientes en el sistema - L -

n_system <- function(time, system){
sum(diff(time) * system[1:(length(time)-1)]) / time[length(time)]
}

# Número promedio de clientes en la cola - Lq -

n_queue <- function(time, queue){
sum(diff(time) * queue[1:(length(time)-1)]) / time[length(time)]
}

# Fracción del tiempo que hay n o menos en la cola

#t_queue_le_n <- function(time, queue, n){
# sum(diff(time) * (queue[1:(length(time)-1)] <= n)) / time[length(time)]
#}

envs.n <- recursos %>%

group_by(replication) %>%
summarise(L = n_system(time, system),
Lq = n_queue(time, queue))
kable(head(envs.n))

# Tiempo promedio en el sistema

w <- function(start_time, end_time){
mean(end_time - start_time)
}

# Tiempo promedio en la cola

wq <- function(start_time, end_time, activity_time){
mean(end_time - start_time - activity_time)
}

# Tiempo promedio en la cola

#n_queue_le_t <- function(start_time, end_time, activity_time){
mean((end_time - start_time - activity_time) < 5)
}

envs.w <- llegadas %>%

filter(finished == TRUE) %>% # Considerar solamente los que han salido del
sistema
group_by(replication) %>%
summarise(W = w(start_time, end_time),
Wq = wq(start_time, end_time, activity_time))
kable(head(envs.w))

#EJERCICIO 3
#En un servidor de la universidad se mandan programas de ordenador para ser
ejecutados.
#Los programas llegan al servidor con una tasa de 10 por minuto. El tiempo medio de

#ejecución de cada programa es de 5 segundos y tanto los tiempos entre llegadas

como los
#tiempos de ejecucion se distribuyen exponencialmente.
#¿Que proporciÓn de tiempo está el servidor desocupado? P0
#¿Cuál es el tiempo esperado total de salida de un programa? W
#¿Cuál es el número medio de programas esperando en la cola del sistema? Lq

Lambda<-10
Mu<-(60/5)

#FORMA 1
servidor<- NewInput.MM1(Lambda,Mu,0)
CheckInput(servidor)
summary(QueueingModel(servidor))

#FORMA 2
set.seed(123456789)
programa<-trajectory() %>%
seize("servidor",amount = 1) %>%
timeout(function() rexp(1,Mu)) %>%
release("servidor",amount = 1)

senv<-simmer() %>%
add_resource("servidor", capacity=1,queue_size=Inf) %>%
add_generator("programa",programa, function() rexp(1, Lambda)) %>%
run(until = 70)

envs <- mclapply(1:100, function(i) {

simmer() %>%
add_resource("servidor", capacity=1, queue_size=Inf) %>%
add_generator("programa", programa, function() rexp(1, Lambda)) %>%
run(until=70) %>%
wrap()})

rec<-get_mon_resources(envs)
lleg<-get_mon_arrivals(envs)

kable(rec)
kable(lleg)

# Número promedio de clientes en el sistema - L -

n_system <- function(time, system){
sum(diff(time) * system[1:(length(time)-1)]) / time[length(time)]
}

# Número promedio de clientes en la cola - Lq -

n_queue <- function(time, queue){
sum(diff(time) * queue[1:(length(time)-1)]) / time[length(time)]
}

envs.n <- rec %>%

group_by(replication) %>%
summarise(L = n_system(time, system),
Lq = n_queue(time, queue))
kable(head(envs.n))
# Tiempo promedio en el sistema
w <- function(start_time, end_time){
mean(end_time - start_time)
}

# Tiempo promedio en la cola

wq <- function(start_time, end_time, activity_time){
mean(end_time - start_time - activity_time)
}

envs.w <- lleg %>%

filter(finished == TRUE) %>% # Considerar solamente los que han salido del
sistema
group_by(replication) %>%
summarise(W = w(start_time, end_time),
Wq = wq(start_time, end_time, activity_time))
kable(head(envs.w))

#----------------------------------------------------------------------------------
---

#INTEGRACIÓN MONTE CARLO

#EJERCICIO 4
#Use simulación para obtener el valor de la integral de [0,1] con fx=exp(e^x)

#Integración manual
h<-function(x){exp(exp(x))}
int.m<-integrate(h,0,1)

#Con MC
set.seed(0)
nsim<-10^6
x1<-h(runif(nsim))
theta1<-mean(x1)
#Respuesta: 6.342009

#IC
par(mar=c(2,2,2,1),mfrow=c(2,1))
curve(h,xlab="Función",ylab="",lwd=2)

estint<-cumsum(x1)/(1:nsim)
esterr<-sqrt(cumsum((x1-estint)^2))/(1:nsim)

plot(estint, xlab="Media y rango de error",type="l",lwd=

2,ylim=mean(x1)+20*c(-esterr[10^4],esterr[10^4]),ylab="")
lines(estint+1.96*esterr,col="gold",lwd=2)
lines(estint-1.96*esterr,col="gold",lwd=2)

#Intervalo de confianza al 95%

l_inf<-estint[nsim]-1.96*esterr[nsim]
l_sup<-estint[nsim]+1.96*esterr[nsim]

data.frame(l_inf,theta1,l_sup)
data.frame(int.m$value, theta1)

#EJERCICIO 5
#Use simulación para obtener el valor de la integral de [0,1] con fx=(1-x^2)^3/2
h<-function(x){sqrt((1-x^2)^3)}
int<-integrate(h,0,1)
set.seed(0)
Y<-h(runif(nsim))
theta<-mean(Y)

estint<-cumsum(Y)/(1:nsim)
esterr<-sqrt(cumsum((Y-estint)^2))/(1:nsim)

plot(estint, xlab="Media y rango de error",type="l",lwd=

2,ylim=mean(Y)+20*c(-esterr[nsim],esterr[nsim]),ylab="")
lines(estint+1.96*esterr,col="pink",lwd=2)
lines(estint-1.96*esterr,col="pink",lwd=2)

#Intervalo de confianza al 95%

l_inf<-estint[nsim]-1.96*esterr[nsim]
l_sup<-estint[nsim]+1.96*esterr[nsim]

data.frame(l_inf,theta,l_sup)
data.frame(int$value, theta)

#EJERCICIO 6
#Use simulación para obtener el valor de la integral de [-2,2] con fx=exp(x+x^2)
h<-function(x){4*exp(16*x^2 -12*x + 2)}
int.m<-integrate(h1,0,1)

set.seed(0)
X<-h(runif(nsim))
theta<-mean(X)

#IC
curve(h,xlab="Función",ylab="",lwd=2)

estint<-cumsum(X)/(1:nsim)
esterr<-sqrt(cumsum((X-estint)^2))/(1:nsim)

plot(estint, xlab="Media y rango de error",type="l",lwd=

2,ylim=mean(X)+20*c(-esterr[nsim],esterr[nsim]),ylab="")
lines(estint+1.96*esterr,col="red",lwd=2)
lines(estint-1.96*esterr,col="red",lwd=2)

#Intervalo de confianza al 95%

l_inf<-estint[nsim]-1.96*esterr[nsim]
l_sup<-estint[nsim]+1.96*esterr[nsim]

data.frame(int.m$value, theta)
data.frame(l_inf,int.m$value,l_sup)

#EJERCICIO 7
#Use simulación para obtener el valor de la integral de [0,Inf] con fx=x(1+x^2)^-2
h<-function(x){x*(1+x^2)^-2}
int.M<-integrate(h,0,Inf)

h1<-function(x){(x*(1-x))/(4*x^4 - 8*x^3 + 8*x^2 -4*x +1)}

int.M1<-integrate(h1,0,1)

set.seed(0)
Y<-h1(runif(nsim))
theta<-mean(Y)
estint<-cumsum(Y)/(1:nsim)
esterr<-sqrt(cumsum((Y-estint)^2))/(1:nsim)

plot(estint, xlab="Media y rango de error",type="l",lwd=

2,ylim=mean(Y)+20*c(-esterr[nsim],esterr[nsim]),ylab="")
lines(estint+1.96*esterr,col="gray",lwd=2)
lines(estint-1.96*esterr,col="gray",lwd=2)

#Intervalo de confianza al 95%

l_inf<-estint[nsim]-1.96*esterr[nsim]
l_sup<-estint[nsim]+1.96*esterr[nsim]

data.frame(l_inf,theta,l_sup)
data.frame(int.M1$value, theta)

#EJERCICIO 8
#Use simulación para obtener el valor de la integral de [-Inf,Inf] con fx=exp(-x^2)
h<-function(x)(2*exp(-x^2))
integrate(h,0,Inf)

#Se generan los valores de la densidad auxiliar y se calculan los pesos:

nsim <- 10^3
y <- rexp(nsim)
w <- h(y)/dexp(y)
mean(w)

#EJERCICIO 9
#Supongamos que se pretende aproximar P (2 < X < 6) siendo X~Cauchy(0, 1) empleando
#muestreo por importancia y considerando como densidad auxiliar Y~N(0, 1).
#Se trata de aproximar pcauchy(6) - pcauchy(2), i.e.
#f(y) = dcauchy(y) y h(y) = (y > 2) * (y < 6), empleando muestreo por importancia
con
#g(y) = dnorm(y).

nsim<-10^5
set.seed(4321)
y <- rnorm(nsim)
w <- dcauchy(y)/dnorm(y)
mean(w* (y > 2) * (y < 6))

pcauchy(6) - pcauchy(2)

#Convergencia:
plot(cumsum(w * (y > 2) * (y < 6))/1:nsim, type = "l", ylab = "Aproximación", xlab
= "Iteraciones")
abline(h = pcauchy(6) - pcauchy(2), lty = 2)
#Conclusión: Lo que indica es una mala elección de la densidad auxiliar. La
distribución
#de los pesos debería ser homogénea

#EJERICIO 10
#Generar 1000 simulaciones de una N(0,1) con una Cauchy(0,1)

nsim<-1000
nsim2<-10^5

set.seed(1234)
y<-rcauchy(nsim2)
w<-dnorm(y)/dcauchy(y)
mean(w)

#Si se pidiera aproximar una integral

h<-function(y){y}
mean(w*h(y))

#Remuestreo del muestreo por importancia

rx <- sample(y, nsim, replace = TRUE, prob = w/sum(w))

#Convergencia
hist(rx, freq = FALSE, breaks = "FD", ylim = c(0, 0.5))
lines(density(rx), lwd=2)
curve(dnorm, col = "blue", add = TRUE)

#IC al 95%
estint<-cumsum(rx)/(1:nsim)
esterr<-sqrt(cumsum((rx-estint)^2))/(1:nsim)

plot(estint, xlab="Media y rango de error",type="l",lwd=

2,ylim=mean(rx)+20*c(-esterr[nsim],esterr[nsim]),ylab="")
lines(estint+1.96*esterr,col="purple",lwd=2)
lines(estint-1.96*esterr,col="pink",lwd=2)

#Intervalo de confianza al 95%

l_inf<-estint[nsim]-1.96*esterr[nsim]
l_sup<-estint[nsim]+1.96*esterr[nsim]

#EJERCICIO 11
#Consideramos una v.a. con densidad:
# f(x) = exp(-x)*cos^2(x) con x>0

#Aproximar mediante integración Monte Carlo la media de esta distribución (h(x) =

x)
#empleando muestreo de importancia con distribución auxiliar una exponencial de
#parámetro lambda = 1 a partir de 10,000 simulaciones
# (OJO: se conoce la cuasi-densidad de la v.a. de interés, emplear la aproximación
# descrita en apuntes).

nsim<-10^4
set.seed(1234)

x<-function(x){exp(-x)*(cos(x))^2}
h<-function(y){y}
y<-rexp(nsim)
w<-x(y)/dexp(y)

sum(w * h(y))/sum(w)
mean(w*h(y))

#EJERCICIO 12
#Usando el método de Monte Carlo aproximar el valor de: f(x,y)= exp(-x-y) con x,y
=(0,1)

h<-function(x,y)exp(-(x+y))

x.llim<-0; x.ulim<-1
y.llim<-0; y.ulim<-1

INT<-integrate(function(y){
 sapply(y, function(y){
integrate(function(x)h(x,y),x.llim,x.ulim)$value
})
},y.llim,y.ulim)

#CON MC
nsim<-10^5
ux<-runif(nsim)
uy<-runif(nsim)

theta<-mean(h(ux,uy))

plot(cumsum(h(ux,uy))/1:nsim, type = "l", ylab = "Aproximación",xlab =

"Iteraciones")
abline(h = (exp(-1)-1)^2, lty = 2,col="red")

data.frame(INT$value,theta)

#EJERCICIO 13
#Calcule Ef[h(X)] cuando f es una funciÓn de densidad normal estándar y
#h(x) = exp(-(x-3)^2 + exp(-(x-6)^2/2)
# (a) Muestre que Ef[h(X)] puede ser calculado de forma cerrada y obtenga su
resultado.
# "sacar la esperanza de la función h con la normal"
# (b) Empleando el método de integración Monte Carlo hallar el valor aproximado de
# Ef [h(X)], use 1000 simulaciones, compare el resultado con su valor real.
# (c) Compare el resultado anterior con la aproximación obtenida por muestreo por
impor-
# tancia basándose en una función por importancia g correspondiente a una
U(0,1),
# use 1000 simulaciones.

# (a) Integral de forma cerrada

f1<-function(x){(1/sqrt(2*pi))*exp(-x^2/2)*(exp(-(x-3)^2) + exp(-(x-6)^2/2))}
Int.1<-integrate(f1,-Inf,Inf)

# (b) Integral con Mc

set.seed(0)
Int.2<-function(nsim)
{
munif<-runif(nsim)
u<-(1/munif)-1
mean((1/sqrt(2*pi))*exp(-u^2/2)*(exp(-(u-3)^2) + exp(-(u-6)^2/2))*(1/munif)^2)
}

Int.2(1000)
data.frame(Int.1$value, Int.2(1000))
# 0.02883184 0.02845214

# (c) Muestreo por importancia

nsim <- 10^3
set.seed(0)

h<-function(x){(exp(-(x-3)^2) + exp(-(x-6)^2/2))}
y <- rnorm(nsim)
w <- dnorm(y)/dnorm(y)

Int.3<-mean(w*h(y))
data.frame(Int.1$value, Int.3)
#EJERCICIO 14
##Simular valores de una normal estándar usando como distribución
#propuesta una uniforme (-4,4).

delta <- 4
N <- 1000
X <- numeric(N)
X[1] <- 0
set.seed(0)

for(i in 2:N) {
eps <- runif(1, -delta, delta)
y <- X[i-1] + eps
alpha <- min(dnorm(y, log = TRUE) - dnorm(X[i-1], log = TRUE), 0)
u <- runif(1, 0, 1)
if(log(u) <= alpha)
X[i] <- y
else
X[i] <- X[i-1]
}
summary(X)
X

hist(X)

library(ggplot2)
qplot(1:N, X, geom = "line", xlab = "Iteration")

#EJERCICIO 15
#Crear una función que implemente la técnica de variables antitéticas
#para aproximar la integral con fx= 0.5*exp(x) para 0<x<2

f<-function(x){0.5*exp(x)}
integrate(f,0,2)

curve(f, ylim=c(0,4))
abline(h=0,lty=2)
abline(v=c(0,2),lty=2)

a<-0
b<-2
#Con MC
mc.integral <- function(f, a, b, n, plot=TRUE) {
fx <- sapply(runif(n, a, b), f)*(b-a)
if (plot) {
estint <- cumsum(fx)/(1:n)
esterr <- sqrt(cumsum((fx-estint)^2))/(1:n)
plot(estint, ylab="Media y rango de error", type="l", lwd= 2,
ylim=mean(fx)+2*c(-esterr[1],esterr[1]), xlab="Iteraciones")
abline(h = estint[n], lty=2)
lines(estint+1.96*esterr, lty = 3)
lines(estint-1.96*esterr, lty = 3)
return(list(valor=estint[n], error=2*esterr[n]))
} else return(list(valor=mean(fx), error=2*sd(fx)/sqrt(n)))
}

set.seed(54321)
res <- mc.integral(f, a, b, 1000)
abline(h = integrate(f,0,2)$value)
data.frame(res, integrate(f,0,2)$value)

#Con variables antiteticas

mc.integrala2 <- function(ftn, a, b, n, plot = TRUE,...) {
x <- runif(n%/%2, a, b)
x <- matrix(c(x,a+b-x),nrow=2,byrow=TRUE)
fx <- apply(x, 1, f)*(b-a)
corr <- cor(fx[,1], fx[,2])
fx <- as.numeric(fx)
return(list(valor=mean(fx), error=2*sd(fx)/sqrt(n)*sqrt(1+corr)))
}
set.seed(54321)
res <- mc.integrala2(f, a, b, 1000)
res

#Porcentaje estimado de reducción del error:

red<-100*(0.1619886-0.05700069)/0.1619886

#EJERCICIO 16
#Simulamos una distribución de Bernoulli de parámetro p = 0.5.
#La aproximación por simulación de p será Xmedia
p <- 0.5
set.seed(1)
nsim <- 10000
rx <- runif(nsim) <= p

mean(rx)

plot(cumsum(rx)/1:nsim, type="l", lwd=2, xlab="Número de simulaciones",

ylab="Proporción muestral", ylim=c(0,1))
abline(h = mean(rx), lty = 2)
abline(h = p)

#EJERCICIO 17
set.seed(1)
nsim <- 10000
rx <- rcauchy(nsim)
plot(cumsum(rx)/1:nsim, type="l", lwd=2,
xlab="Número de simulaciones", ylab="Media muestral")

#EJERCICIO 18
xsd <- 1
xmed <- 0
set.seed(1)
nsim <- 1000
rx <- rnorm(nsim, xmed, xsd)

#La aproximación por simulación de la media será:

mean(rx)

#Como medida de la precisión de la aproximación podemos considerar:

2*sd(rx)/sqrt(nsim)

#Intervalos
n <- 1:nsim
est <- cumsum(rx)/n
esterr <- sqrt(cumsum((rx-est)^2))/(n - 1) # Error estandar
plot(est, type = "l", lwd = 2, xlab = "Número de simulaciones",
 ylab = "Media y rango de error", ylim = c(-1, 1))
abline(h = est[nsim], lty=2)
lines(est + 1.96*esterr, lty=3)
lines(est - 1.96*esterr, lty=3)
abline(h = xmed)

#EJERCICIO 19
#Sean U1,U2 variables aleatorias i.i.d. uniformes (0,1).
#Sea U3 = 1-U1 una variable aleatoria uniforme (0,1).
#Sea g(x) = exp(x^2), theta = integral de 0 a 1 de g(x).
#Quiero mostrar que:
#theta2= (exp(U1^2) + exp(U3^2)) /2 = (exp(U1^2) + exp((1-U1)^2)) /2 = exp(U1^2)[1
+ exp(1-2U1)] /2
#es mejor estimador que
#theta1 = (exp(U1^2) + exp(U2^2)) /2

#Esto es que la varianza de theta2 sea menor a la de theta1, por

#lo tanto queremos ver que la covarianza de theta2 sea siempre menor a la de
theta1.

n1<-10; n2<-10000
U1<-c(); U2<-c(); U3<-c()
X1<-c(); X2<-c(); X3<-c()
esp1<-c(); esp2<-c(); esp3<-c()
theta1<-c(); theta2<-c()
cov1<-c(); cov2<-c()
I<-c()

for(j in 1:n1){

U1<-runif(n2);
U2<-runif(n2);
U3<-1-U1;

for(i in 1:n2){
X1[i]<-exp((U1[i])^2)
X2[i]<-exp((U2[i])^2)
X3[i]<-exp((U3[i])^2)
}
esp1[j]<-mean(X1)
esp2[j]<-mean(X2)
esp3[j]<-mean(X3)

theta1[j]<-(esp1[j]+esp2[j])/2
theta2[j]<-(esp1[j]+esp3[j])/2
cov1[j]<-cov(X1,X2)
cov2[j]<-cov(X1,X3)
}
data.frame(cov1[j],cov2[j])
#como cov2<0, es mejor estimador

#EJERCICIO 20
#Se desea estimar la integral de theta = g(X) = exp((X)^2) con 0<x<1

#Integral de forma cerrada:

h<-function(x,y)exp(x^2)
Integral<-integrate(h,0,1)

#Con MC = Se usa g(U1)=exp((U1)^2) con U1~U(0,1)

set.seed(7)
it<-100
theta<-vector(length=it)
for(j in 1:it){

U<-runif(1000,0,1)
x<-vector(length=1000)

for (i in 1:1000){
x[i]<-exp(U[i]^2)
}

teta<-mean(x)
theta[j]<-teta
}

var<-sd(theta)^2
mean(theta)
data.frame(Integral$value,mean(theta))

#Con Método de Control

#Se propone la función g(x)= 1.5*x^2 + 1 con X~N(0,1)
curve(exp (x^2), col="green",xlim=c(0,1),ylim=c(0,3),main="Comparación entre f(x) y
g(x)",ylab="y")
curve(1.5*(x^2) +1, xlim=c(0,1), col="red", add=T)

set.seed(7)
miu<-1.5
theta_cont<-vector()

for(j in 1:100){
f<-c()
g<-c()
u<-runif(1000,0,1)

for (i in 1:1000){
f[i]<-exp(u[i]^2)
g[i]<-1.5*(u[i]^2)+1

var_g<-sd(g)^2
cov<-cov(f,g)
c<-cov/var_g
teta_cont<-mean(f-c*g)+c*miu

theta_cont[j]<-teta_cont
}

mean(theta_cont)
var_control<-sd(theta_cont)^2

data.frame(Integral$value,mean(theta), mean(theta_cont),c)
red_varC<-(var-var_control)/var

#Con variables antitéticas

set.seed(7)
it1<-100
theta1<-vector(length=it1)
theta2<-vector(length=it1)
for(j in 1 :it1){
y<-runif(1000,0,1)
w<-1-y
Y<-vector(length=1000)
W<-vector(length=1000)
for(i in 1:1000){
Y[i]<-exp(y[i]^2)
W[i]<-exp(w[i]^2)

teta1<-mean(Y)
teta2<-mean(W)

theta1[j]<-teta1
theta2[j]<-teta2
}

thata3<-(theta1+theta2)/2

mean(thata3)
data.frame(Integral$value,mean(theta), mean(theta_cont),mean(thata3))
var_min<-sd(thata3)^2
red_varA<-(var-var_min)/var

#EJERCICIO 21
#Aproximar mediante MC la media de una distribución exponencial de parámetro
lambda=2.

nsim <- 1000

lambda <- 0.5
set.seed(1)
x <- - log(runif(nsim)) / lambda #Con método de la transformada inversa
MC<-mean(x)

#EJERCICIO 22
#Suponer Y∼N(mean=μ,Var=1/τ).Sobre la base de una muestra, obtenga las
distribuciones
#posteriores de μ y τ usando la muestra de Gibbs.

n <- 30
ybar <- 15
s2 <- 3
sim<-10^5

mu <- rep(NA, sim)

tau <- rep(NA, sim)
T <- 1000 #calentamiento
tau[1] <- 1 #valor inicial
for(i in 2:sim) {
mu[i] <- rnorm(1, ybar, sqrt(1 / (n * tau[i - 1])))
tau[i] <- rgamma(1,n/2, 2 / ((n - 1) * s2 + n * (mu[i] - ybar)^2))
}

#Valores de calentamiento
#mu <- mu[-(1:T)]
#tau <- tau[-(1:T)]
par(mfrow=c(1,2))
hist(mu,freq=F,xlab="mu", ylab="Densidad marginal", col = "pink", main = "")
hist(tau,freq=F,xlab="tau", ylab="Densidad marginal", col = "gray", main = "")

#EJERCICIO 23
#Use simulación con variables antiteticas para calcular:
#f(X,Y)= sin(x+y)*exp(-x^2+4*x-y) con -Inf<y<Inf & 0<x<Inf

func <- function(x,y) {sin(x+y)*exp(-x^2 + 4*x - y)}

llim.x <- 0; ulim.x <- Inf
llim.y <- -Inf; ulim.y <- Inf
integrate(function(y) {
sapply(y, function(y) {
integrate(function(x) func(x,y), llim.x, ulim.x)$value
})
}, llim.y, ulim.y)

g <- function(u, v) {
x <- qnorm(u, 2, sqrt(1/2))
y <- qexp(v)
exp(4) * sqrt(pi) * sin(x + y)
}

N <- 500
Antitetica<-system.time(sim1 <- replicate(10^4, {u <- runif(N); v <- runif(N);
mean(g(c(u, 1-u), c(v, 1-v))) }))
MC<-system.time(sim2 <- replicate(10^4, {u <- runif(2*N); v <- runif(2*N);
mean(g(u,v)) }))

hist(sim2, freq=FALSE, breaks=20, ylim=c(0, 0.75*sqrt(N/1000)), col="#5b5be0b0",

xlab="Estimate", main="")
hist(sim1, freq=FALSE, breaks=20, add=TRUE, col="#e05b5bb0")
abline(v = exp(15/4) * sqrt(pi) * (cos(2) + sin(2))/2, lwd=2)

u <- runif(10^4); v <- runif(10^4)

g0 <- g(u, v)
g1 <- g(1-u, 1-v)
plot(g0, g1, asp=1, pch=16, col="#00000020", cex=0.75,
xlab="Values", ylab="Antithetic Values",
main=paste("Correlación", format(cor(g0, g1), digits=2)))

#EJERCICIO 24
#Sea X~t con 8 grados de libertad, con función de densidad con f(x)=x^5*t8 con
2.1<x<Inf.
#Obtener una aproximación de la integral utilizando:
#Simulaciones directas de la v.a. t8 􀀀 Student.
#Muestreo por importancia con
# Cauchy(0,1)
# Normal(0,1)
# Uniforme (0,1/2.1)
#Realice 100 simulaciones, obtenidas mediante muestreo por importancia
#con 1000 observaciones de cada una de las distribuciones alrededor
#del valor verdadero de la integral, identifique cuál es la mejor distribución
#para llevar a cabo la simulación.

t<-function(x){x^5*dt(x,8)}
Integral.M<-integrate(t,2.1,Inf)
#Con t-Student con k=8
mues.t<-matrix(nrow=1000, ncol=100)
for(j in 1:100) mues.t[,j]<-rt(1000,8)

h.muest.t<-matrix(nrow = 1000,ncol = 100)

for (j in 1:100) {
for(i in 1:1000){
if(mues.t[i,j]>2.1) h.muest.t[i,j]<-(mues.t[i,j])^5 else h.muest.t[i,j]<-0
}

}
I.mues<-apply(h.muest.t,2,mean)
plot(I.mues, type = 'l')
abline(h=valor)
mean(I.mues)
sd(I.mues)

#Con Cauchy(0,1)
mues.c<-matrix(nrow=1000, ncol=100)
for(j in 1:100) mues.c[,j]<-rcauchy(1000)

h.muest.c<-matrix(nrow = 1000,ncol = 100)

for (j in 1:100) {
for(i in 1:1000){
if(mues.c[i,j]>2.1)
h.muest.c[i,j]<-(mues.c[i,j])^5*(dt(mues.c[i,j],8))/(dcauchy(mues.c[i,j]))
else h.muest.c[i,j]<-0
}

}
I.mues.c<-apply(h.muest.c,2,mean)
plot(I.mues.c, type = 'l')
abline(h=valor)
mean(I.mues)
sd(I.mues)

#Con Normal(0,1)
mues.n<-matrix(nrow=1000, ncol=100)
for(j in 1:100) mues.c[,j]<-rnorm(1000)

h.muest.n<-matrix(nrow = 1000,ncol = 100)

for (j in 1:100) {
for(i in 1:1000){
if(mues.n[i,j]>2.1)
h.muest.n[i,j]<-(mues.n[i,j])^5*(dt(mues.n[i,j],8))/(dcauchy(mues.n[i,j]))
else h.muest.n[i,j]<-0
}

}
I.mues.n<-apply(h.muest.n,2,mean)
plot(I.mues.n, type = 'l')
abline(h=valor)
mean(I.mues)
sd(I.mues)

#Transformación y=x/2,1
#EJERCICIO 25
#Evaluar E(x) una distribución objetivo f(x)=2*x*exp(-x^2), x>0
#Al usar el muestreo de importancia, tomo una distribución de propuesta
#g(x)=exp(-x) ~Exp(1)

set.seed(0)
x <- rexp(1000)
f <- function(x) {2*x*exp(-x^2)}
w <- f(x) / dexp(x)
mean(w * x)

fx<-function(x){2*x*exp(-x^2)}
I<-integrate(fx,0,Inf)

data.frame(I$value,mean(w*x))

#EJERCICIO 26
#Calcular g(x) = 4*sqrt(1-x) con 0 < x < 1. Use Monte Carlo

MC<-function(n){
y<-4*sqrt(1-runif(n)^2)
theta<-mean(y)
Z<-1.96*sqrt(var(y)/n)
L.Inf<-theta-Z
L.Sup<-theta+Z
c(L.Inf,theta,L.Sup)
}
E<-MC(10000)