Examen Final - Análisis Numérico (Uba Fce)

Económicas, UBA. Actuario. Análisis Numérico.
Cuatrimestre 1, 2021. Examen FINAL.

Para aprobar, debe sumar 50 puntos.
Los parámetros de su examen en particular se encuentran en el documento
‘ParametrosFINAL.png’ entregados por el profesor.
Remplace este texto por su Apellido y Nombre, y su Numero de Registro.
08/julio/2021
Contents
1 Resolución de Ecuaciones: Punto Fijo (20 puntos) 3
1.1 Graficar la función . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.2 Corregir algoritmo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
1.3 Hallar raíces . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.4 Graficar los puntos fijos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.5 Iteraciones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
2 Integral Densidad Beta (20 puntos) 7

2.1 Estimación de Función Gamma . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
2.2 Simpson y Trapecio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
2.3 Esperanza Matemática . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
2.4 Esperanza Matemática de una función condicional . . . . . . . . . . . . . . . . . . . . . . . . 13
3 Integración y Derivación Numérica (20 puntos) 15

3.1 E(S|µ; σ) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
3.2 Derivada respecto a µ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
3.3 Derivada respecto a σ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
3.4 Función E(S|µ; σ) = f (σ) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
4 Interpolación (20 Puntos) 18

4.1 Polinomio de Newton: PN (x) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
4.2 Interpolar con PN (x) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
4.3 Cubic Splines: Si (x) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
4.4 Interpolar con Si (x) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
4.5 Graficar . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
1
5 Derivación Numérica (10 puntos) 26
5.1 Estime P ′ (x). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
5.2 Estime P ′′ (x). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
6 SQL (10 puntos) 29

6.1 Consulta empleados . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
6.2 Consulta Clientes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
2
1 Resolución de Ecuaciones: Punto Fijo (20 puntos)
Considere la siguiente ecuación: sin(x)/x + x3 + 2x2 = 1.5.
1.1 Graficar la función
Plantee la ecuación de la forma f (x) = 0 y grafique la función en el intervalo [−1; 1] de manera tal que pueda
identificar todas las soluciones de la ecuación en el intervalo. Indique un intervalo aproximado que contenga
cada una de las raíces identificadas.
Respuesta:
# Ingrese en este bloque todo el código necesario para resolver el ejercicio 1.1
#Fixed-Point
fn <- function(x) #Funcion
{
f <- sin(x)/x + xˆ3 + 2*xˆ2-1.5
return(f)
}
g <- function(x){ # Funcion g(x) para la iteracion de punto fijo

gn <- (sin(x) + xˆ4 + 2*xˆ3) /1.5
return(gn)
}
plot(g,pch = 21,cex=1.5,lwd=0.5,bg="black", ylim = c(-1,1), xlim = c(-1,1))

abline(h=0)
Posible_raiz <- 0
points(Posible_raiz,0,pch = 21,cex=1,lwd=0.5,bg="blue")
3
1.0
0.5
0.0
g
−0.5
−1.0
−1.0 −0.5 0.0 0.5 1.0
1.2 Corregir algoritmo
CORREGIR el algoritmo “PuntoFijo” en el siguiente bloque de código.

COMENTAR los cambios que realizó (use “#” al final de cada línea modificada).
[Notar que, para el resto del ejercicio, no debe utilizar su propio algoritmo, sino que debe usar
el algoritmo dado y corregido, sin agregar ninguna línea de código adicional.]
Respuesta:
PuntoFijo <- function(g,p0,Tol,N){

i = 1
while (i <= N){
p = g(p0) # cambio p por p0
if (abs(p0-p) < Tol){ #Agrego llaver a la funcion if
return(p) #la tol debe ser mayor y devuelve p
}
i = i + 1 # modifico el ==
p0 = p
}
return(paste('El algoritmo falla luego de ', N, ' iteraciones'))
}
PF = PuntoFijo(g,0, 0.001, 10000)
4
1.3 Hallar raíces
Utilizando el algoritmo del punto 1.2, halle todas las raíces identificadas en el punto 1.1. Halle en primer
lugar la función g(x) (o las funciones), y chequee el cumplimiento de las condiciones de existencia en cada
solución.
[OBSERVACIÓN : Debe usar el algoritmo dado en 1.2 (corregido por usted). No puede usar su propio
algoritmo.]
Respuesta:
PF = PuntoFijo(g,0, 0.001, 10000)
Raiz_1 <- PuntoFijo(g,0, 0.001, 10000)

plot(g,pch = 21,cex=1.5,lwd=0.5,bg="black", ylim = c(-1,1), xlim = c(-1,1))
abline(h=0)
points(Raiz_1,0,pch = 21,cex=1,lwd=0.5,bg="red")
1.0
0.5
0.0
g
−0.5
−1.0
−1.0 −0.5 0.0 0.5 1.0
1.4 Graficar los puntos fijos
Grafique la función o las funciones g(x) (que utilizó para hallar las raíces de f (x)) e identifique los puntos
fijos hallados en el punto 1.3. En el gráfico (o en cada gráfico), marque las coordenadas de cada punto fijo
g(x) = x con un punto de color rojo.
5
1.5 Iteraciones
Tome el algoritmo del punto 1.2 (copie y pegue) y agregue las líneas de código que considere necesarias
para poder visualizar (imprimir) cada iteración del algoritmo. Una vez editado el algoritmo, imprima niter
iteraciones del algoritmo iniciando en x0 . ¿A cuál de las raíces convergeria el algortimo en este caso?
Respuesta:
6
2 Integral Densidad Beta (20 puntos)
Considere la siguiente función de densidad de la variable aleatoria Y , con dominio en el intervalo Y ∈ (0; 1),
y parámetros α y β:
Γ(α + β) α−1
fY (x|α, β) = x (1 − x)β−1
Γ(α)Γ(β)
R∞
La función Γ(z) está definida por la siguiente integral: Γ(z) = 0
tz−1 e−t dt.
2.1 Estimación de Función Gamma
Aproxime los valores de la función Γ(z) que se incluyen en la función de densidad usando Trapecio Compuesto
con n = 1000 y un valor de límite superior que considere adecuado.
# 1) Cargo Algoritmo Trapecio ----
trapecio.compuesto = function(fn, a, b, n){
h = (b-a)/n
xio = fn(a) + fn(b)

xi = 0
for (i in 1:(n-1)) {
x = a + i*h
xi = xi + fn(x)
}
val = h*(xio + 2*xi)/2
return(val)
}
# 2) Defino variables ----
gamma = function(t){(tˆ(z-1))*exp(-t)}
alfa = 3.72
beta = 3.10
#Alfa + Beta
z = 6.82
(gam1 <- trapecio.compuesto(f = gamma, a = 10ˆ-4,b = 200, n = 1000))
## [1] 515.2543
curve(gamma)
7
0.3
gamma(x)
0.2
0.1
0.0
0.0 0.2 0.4 0.6 0.8 1.0
#Alfa
z= 3.72
(gam2 <- trapecio.compuesto(f = gamma,a = 10ˆ-4,b = 200, n = 1000))
## [1] 4.269439
curve(gamma)
8
0.3
gamma(x)
0.2
0.1
0.0
0.0 0.2 0.4 0.6 0.8 1.0
#Beta
z = 3.10
(gam3 <- trapecio.compuesto(f = gamma,a = 10ˆ-4,b = 200, n = 1000))
## [1] 2.197628
curve(gamma)
9
0.3
gamma(x)
0.2
0.1
0.0
0.0 0.2 0.4 0.6 0.8 1.0
f =function(x){ (gam1/(gam2*gam3))*(xˆ(alfa-1))*((1-x)ˆ(beta-1))}
curve(f)
10
2.0
1.5
f(x)
1.0
0.5
0.0
0.0 0.2 0.4 0.6 0.8 1.0
2.2 Simpson y Trapecio
Aproxime la probabilidad de que S esté entre a y b usando los métodos de “Trapecio”, “Simpson” y “Simpson
tres octavos”. Indique en cada caso los “nodos” x0 , x1 , . . . , xn que se utilizan para la aproximación.
Respuesta:
2.3 Esperanza Matemática
Use Simpson Compuesto con n = N2 para aproximar E(Y ); es decir, la esperanza matemática de Y . Calcule
la cota del error.
Respuesta:
RCSimps <- function(f,a,b,n) {
if (n %% 2 == 0){
h = (b-a)/n
xI0 = f(a)+f(b)
xI1 = 0 #suma de f(x2i-1)
xI2 = 0 #suma de f(x2i)
X = rep(NA,n)
for (i in 1:(n-1)) {
11
X[i]= a + i*h
if (i %% 2 == 0){
xI2 = xI2 + f(X[i])
}
else {xI1 = xI1 + f(X[i])}
}
fXI = h*(xI0 + 2*xI2 + 4*xI1)/3
return(fXI)
}
else (return("n debe ser par"))
}
EY <- function(x){x*(gam1/(gam2*gam3))*(xˆ(alfa-1))*((1-x)ˆ(beta-1))}
(EY1 <- RCSimps(EY,10ˆ-10,1,700)) #Esperanza de Y
## [1] 0.5454499
AUX=(gam1/(gam2*gam3))
#Calculo cota de error
ge = expression((x*(AUX*xˆ(3.72-1)*(1-x)ˆ(3.10-1))))
g_d4_v2 = function(x) {eval(D(D(D(D(ge,'x'),'x'),'x'),'x'))} #Calculo la derivada 4ta para la cota
#Hago la curva para analizar los maximos y minimos en el dominio
curve(g_d4_v2,0,2,col = 'red')
(max1 = optimize(g_d4_v2,c(0.5,1.5),maximum = T))
## Warning in optimize(g_d4_v2, c(0.5, 1.5), maximum = T): NA/Inf replaced by

## maximum positive value
## $maximum
## [1] 0.8599233
##
## $objective
## [1] 3056.434
points(max1$maximum,max1$objective)
12
0
−5000
g_d4_v2(x)
−15000
0.0 0.5 1.0 1.5 2.0
N= 700
h=1/N
cota=max1$objective*hˆ4*1/180
print(paste("Cota de error=",round(cota,15)))
## [1] "Cota de error= 7.0721e-11"
2.4 Esperanza Matemática de una función condicional
Use Simpson Compuesto con n = N2 para aproximar E[max(Y − 0.40; 0)]; es decir, la esperanza matemática
de una función condicional que toma el valor Y −0, 40 siempre y cuando sea positivo, y cero en caso contrario.
Respuesta:
h <- function (x) ifelse(x-0.40>0,x-0.4,0)
Esp_Cond<-function(x){
return(h(x)*f(x))
}
curve(Esp_Cond,0,1,col="black")
13
0.5
0.4
Esp_Cond(x)
0.3
0.2
0.1
0.0
0.0 0.2 0.4 0.6 0.8 1.0
#Caluclo la esperanza por

RDO=RCSimps(Esp_Cond,0.4,1,N)
print(paste("La esperanza condicionada es=",round(RDO,4)))
## [1] "La esperanza condicionada es= 0.1677"
14
3 Integración y Derivación Numérica (20 puntos)
Considere la siguiente función de densidad de la variable S:
1 (ln (x)−µ)2
fS (x) = √ e− 2σ 2 ; con x > 0.
xσ 2π
3.1 E(S|µ; σ)
Calcule mediante una integral numérica, usando Simpson Compuesto con n = 1000, la esperanza matemática
de la variable aleatoria S.
mu=3.35
sigma=0.23
Fs_x<-function(x){
return((1/(x*sigma*sqrt(2*pi)))*exp((log(x)-mu)ˆ2/(2*sigmaˆ2)*(-1)))
}
Esp_Mate<-function(x){
return(x*Fs_x(x))
}
curve(Esp_Mate,0,80)
1.5
Esp_Mate(x)
1.0
0.5
0.0
0 20 40 60 80
15
fn = function(x){
val = (x*Fs_x(x))
return(val)
}
simpson.compuesto = function(a, b, n){

if((n %% 2) == 0){
#Paso 1
h = (b-a)/n
#Paso 2
xio = fn(a) + fn(b)
xi1 = 0 #Suma impar
xi2 = 0 #Suma par
#Paso 3
for (i in 1:(n-1)) {
#Paso 4
x = a + i*h
#Paso 5
if((i %% 2) == 0){
xi2 = xi2 + fn(x)
}else{
xi1 = xi1 + fn(x)
}
}
#Paso 6
val = h*(xio + 2*xi2 + 4*xi1)/3
return(val)
}
else return("n debe ser par")
}
Rdo <-(simpson.compuesto(10ˆ-10,80,1000))
print(paste("La esperanza será",round(Rdo,4)))
## [1] "La esperanza será 29.2664"
3.2 Derivada respecto a µ
Estime numéricamente la derivada de E(S|µ; σ) respecto del parámetro µ.
h = 0.00001
mu_h=mu+h
(derivada_con_respescto_mu=(Esp_Mate(mu_h)-Esp_Mate(mu))/(h))
## [1] 3.194716e-18
16
3.3 Derivada respecto a σ
Estime numéricamente la derivada de E(S|µ; σ) respecto del parámetro σ.
sigma_h=sigma+h
(derivada_con_respescto_sigma=(Esp_Mate(sigma_h)-Esp_Mate(sigma_h))/(h))
## [1] 0
3.4 Función E(S|µ; σ) = f (σ)
Cree una función f (x) cuya imagen sea E(S|µ; x), considerando fijo el valor de µ dado. Grafique la función
para x ∈ (0; 0.5).
17
4 Interpolación (20 Puntos)
Considere la siguente tabla de datos:
x y
2.500 0.0013
4.375 0.0122
6.250 0.0668
8.125 0.2266
10.000 0.5000
11.875 0.7734
13.750 0.9332
15.625 0.9878
17.500 0.9987
4.1 Polinomio de Newton: PN (x)
Escriba el Polinomio interpolante de Newton, PN (x), que pasa por los nueve puntos dados.
Respuesta:
x=c(2.5,4.375,6.250,8.125,10.000,11.875,13.750,15.625 ,17.500)
fx=c(0.0013,0.0122,0.0668,0.2266,0.5000,0.7734,0.9332,0.9878,0.9987)
A=cbind(x,fx)
View(A)
#Cargo Diferencias Divididas ----

Dif_Div=function(A){
n=A[,1]
m=A[,2]
b=2
k=nrow(A)-1
for(i in 1:k){
a=rep(0,nrow(A))
for(j in b:nrow(A)){
a[j]=(m[j]-m[j-1])/(n[j]-n[j-ncol(A)+1])
}
A=cbind(A,a)
b=b+1
m=A[,2+i]
}
return(A)
}
Dif_Div(A)
## x fx a a a a
## [1,] 2.500 0.0013 0.000000000 0.000000000 0.0000000000 0.000000e+00
18
## [2,] 4.375 0.0122 0.005813333 0.000000000 0.0000000000 0.000000e+00
## [3,] 6.250 0.0668 0.029120000 0.006215111 0.0000000000 0.000000e+00
## [4,] 8.125 0.2266 0.085226667 0.014961778 0.0015549630 0.000000e+00
## [5,] 10.000 0.5000 0.145813333 0.016156444 0.0002123852 -1.790104e-04
## [6,] 11.875 0.7734 0.145813333 0.000000000 -0.0028722568 -4.112856e-04
## [7,] 13.750 0.9332 0.085226667 -0.016156444 -0.0028722568 2.312965e-19
## [8,] 15.625 0.9878 0.029120000 -0.014961778 0.0002123852 4.112856e-04
## [9,] 17.500 0.9987 0.005813333 -0.006215111 0.0015549630 1.790104e-04
## a a a a
## [1,] 0.000000e+00 0.000000e+00 0.000000e+00 0.000000e+00
## [2,] 0.000000e+00 0.000000e+00 0.000000e+00 0.000000e+00
## [3,] 0.000000e+00 0.000000e+00 0.000000e+00 0.000000e+00
## [4,] 0.000000e+00 0.000000e+00 0.000000e+00 0.000000e+00
## [5,] 0.000000e+00 0.000000e+00 0.000000e+00 0.000000e+00
## [6,] -2.477602e-05 0.000000e+00 0.000000e+00 0.000000e+00
## [7,] 4.387046e-05 6.101910e-06 0.000000e+00 0.000000e+00
## [8,] 4.387046e-05 -1.084202e-20 -4.649074e-07 0.000000e+00
## [9,] -2.477602e-05 -6.101910e-06 -4.649074e-07 2.541099e-22
A=Dif_Div(A)
coef=NULL
for(i in 1:nrow(A)){
coef = as.vector(c(coef,A[i,i+1]))
}
j=("(x-a)")
e=c("1")
u=c(coef[1])
for(c in 2:length(coef)){
a=x[c-1]
e=paste(c(e,gsub("a",a,j)),collapse ="*")
u=c(u,paste(c(e,coef[c]),collapse = "*"))
}
e=parse(text=(paste(u,collapse="+")))
names(e)=c("f(x)")
Ej.4.1_Escribe_Newton = e #este es el Polinomio de Lagrange escrito mediante la forma de diferencias div

Ej.4.1_Escribe_Newton
## expression(‘f(x)‘ = 0.0013 + 1 * (x - 2.5) * 0.00581333333333333 +

## 1 * (x - 2.5) * (x - 4.375) * 0.00621511111111111 + 1 * (x -
## 2.5) * (x - 4.375) * (x - 6.25) * 0.00155496296296296 + 1 *
## (x - 2.5) * (x - 4.375) * (x - 6.25) * (x - 8.125) * -0.00017901037037037 +
## 1 * (x - 2.5) * (x - 4.375) * (x - 6.25) * (x - 8.125) *
## (x - 10) * -2.47760241426612e-05 + 1 * (x - 2.5) * (x -
## 4.375) * (x - 6.25) * (x - 8.125) * (x - 10) * (x - 11.875) *
## 6.10191002591068e-06 + 1 * (x - 2.5) * (x - 4.375) * (x -
## 6.25) * (x - 8.125) * (x - 10) * (x - 11.875) * (x - 13.75) *
## -4.64907430545577e-07 + 1 * (x - 2.5) * (x - 4.375) * (x -
## 6.25) * (x - 8.125) * (x - 10) * (x - 11.875) * (x - 13.75) *
## (x - 15.625) * 2.5410988417629e-22)
19
4.2 Interpolar con PN (x)
Calcule PN (x0 ).
Respuesta:
# Polinomio evauado ----
#Dos formas de resolverlo:

#Primera:
PN <- function(x) {(0.0013+1*(x-2.5)*0.00581333333333333+1*(x-2.5)*(x-4.375)*0.00621511111111111+1*(x-2.
PN(12.61)
## [1] 0.8524037
#0.8524037
#Segundo, modificando el algoritmo para uqe solo interpole

# Dif Divididas o Newton - Solo interpola ----
P_Newton_SoloInterpola = function(A,xk){
b=nrow(A)-1 #este fragmento del codigo se corresponde al calculo de las diferencias div.
n=A[,1]
m=A[,2]
B=seq(n[1],n[length(n)],length.out = 1000) #los valores sobre los cuales se interpolará para graficar
names=c("x","f(x)")
b=2 #calculo de las diferencias div
k=nrow(A)-1
for(i in 1:k){
a=rep(NA,nrow(A))
for(j in b:nrow(A)){
a[j]=(m[j]-m[j-1])/(n[j]-n[j-ncol(A)+1])
}
A=cbind(A,a)
b=b+1
m=A[,2+i]
}
coef=NULL
for(i in 1:nrow(A)){
coef = as.vector(c(coef,A[i,i+1]))
}
#Ahora se interpola el punto especificado.
interpolador=coef[1]
for(f in 1:k){
u=1
for(p in 1:f){
u=u*(xk-n[p])
}
interpolador=interpolador+(coef[f+1])*u
}
return(interpolador)
}
x=c(2.5,4.375,6.250,8.125,10.000,11.875,13.750,15.625 ,17.500)
20
fx=c(0.0013,0.0122,0.0668,0.2266,0.5000,0.7734,0.9332,0.9878,0.9987)
A=cbind(x,fx)
# Interpola en un punto dado ----

Ej.4.2_Dif_Dividadas_Solo_Interpola = P_Newton_SoloInterpola(A,12.61)
Ej.4.2_Dif_Dividadas_Solo_Interpola
## [1] 0.8524037
4.3 Cubic Splines: Si (x)
Escriba los trazadores cúbicos, Si (x); i = 1, ..., n que pasan por todos los puntos dados. Indique claramente
qué polinomio Si se debe usar en cada intervalo de x.
Respuesta:
x=c(2.5,4.375,6.250,8.125,10.000,11.875,13.750,15.625 ,17.500)
fx=c(0.0013,0.0122,0.0668,0.2266,0.5000,0.7734,0.9332,0.9878,0.9987)
A=cbind(x,fx)
Natural_Cubic_Spline_SoloPol = function(A){
#Variables iniciales ----
x = A[,1]
fx = A[,2]
if(length(x)!=length(fx)){
return("La cantidad de argumentos no coincide")
}
n = length(A[,1]); b = c(rep(NA,n)); c = c(rep(NA,n)); d = c(rep(NA,n)); h = c(rep(NA,n))
a = c(rep(NA,n)); l = c(rep(NA,n)); u = c(rep(NA,n)); z = c(rep(NA,n))
#Paso 1 y 2 ----
for(i in 1:(n-1)){
h[i] = x[i+1]-x[i]
}
for(i in 2:(n-1)){
a[i] = ((3/(h[i])) * (fx[i+1]- fx[i])) - ((3/(h[i-1])) * (fx[i]- fx[i-1]))
}
#Paso 3 ----
l[1] = 1;u[1] = 0;z[1] = 0
#Paso 4 ----
for(i in 2:(n-1)){
l[i] = 2*(x[i+1] - x[i-1]) - (h[i-1]*u[i-1])
u[i] = h[i]/l[i]
z[i] = (a[i]- h[i-1]*z[i-1])/l[i]
}
#Paso 5 ----
l[n] = 1 ;z[n] = 0;c[n] = 0
#Paso 6 ----
for(j in (n-1):1){
c[j] = z[j] - (u[j]*c[j+1])
b[j] = ((fx[j+1] - fx[j])/h[j]) - h[j]*(c[j+1] + 2*c[j])/3
d[j] = (c[j+1] - c[j])/(3*h[j])
21
}
Pol = NULL
for(i in 1:(n-1)){
Pol = c(Pol,paste("",fx[i],"+(",b[i],"*(x-",x[i],"))+(",c[i],"*((x-",x[i],")ˆ2))+(",d[i],"*((x-",x[i
}
Pol = matrix(Pol,nrow = (n-1), ncol = 1, byrow = T)
e = NULL
for(i in 1:(n-1)){
e = c(e,paste("S.",i,"(x) = ",sep = ""))
}
dimnames(Pol) = list(e,NULL)
return(Pol)
}
Ej.4.3_Cubic_Spline_Solo_Trazador = Natural_Cubic_Spline_SoloPol(A)
Ej.4.3_Cubic_Spline_Solo_Trazador
## [,1]
## S.1(x) = "0.0013+(0.00249619047619048*(x-2.5))+(0*((x-2.5)^2))+(0.000943542857142857*((x-2.5)^3))
## S.2(x) = "0.0122+(0.012447619047619*(x-4.375))+(0.00530742857142857*((x-4.375)^2))+(0.00191173756613
## S.3(x) = "0.0668+(0.0525133333333333*(x-6.25))+(0.0160609523809524*((x-6.25)^2))+(0.0007392846560846
## S.4(x) = "0.2266+(0.120539047619048*(x-8.125))+(0.0202194285714286*((x-8.125)^2))+(-0.00359456507936
## S.5(x) = "0.5+(0.158450476190476*(x-10))+(-3.46944695195361e-18*((x-10)^2))+(-0.00359456507936508*((
## S.6(x) = "0.7734+(0.120539047619048*(x-11.875))+(-0.0202194285714286*((x-11.875)^2))+(0.000739284656
## S.7(x) = "0.9332+(0.0525133333333333*(x-13.75))+(-0.0160609523809524*((x-13.75)^2))+(0.0019117375661
## S.8(x) = "0.9878+(0.012447619047619*(x-15.625))+(-0.00530742857142856*((x-15.625)^2))+(0.00094354285
4.4 Interpolar con Si (x)
Usando los trazadores cúbicos, interpole los datos para el valor x = x0 .

Respuesta:
#Dos formas de resolverlo:
#Primera, tomo el intervalo que contiene al x0 que busco interpolar:
CB <- function(x){0.7734+(0.120539047619048*(x-11.875))+(-0.0202194285714286*((x-11.875)ˆ2))+(0.00073928
CB(12.61)
## [1] 0.8513667
#Segunda, modificando el algoritmo para que solo interpole:

Natural_Cubic_Spline_SinGraficar = function(A,xk){
#Variables iniciales ----
x = A[,1]
fx = A[,2]
}
22
#Paso 1 y 2 ----
for(i in 1:(n-1)){
h[i] = x[i+1]-x[i]
}
for(i in 2:(n-1)){
}
#Paso 3 ----
l[1] = 1;u[1] = 0;z[1] = 0
#Paso 4 ----
for(i in 2:(n-1)){
l[i] = 2*(x[i+1] - x[i-1]) - (h[i-1]*u[i-1])
u[i] = h[i]/l[i]
z[i] = (a[i]- h[i-1]*z[i-1])/l[i]
}
#Paso 5 ----
l[n] = 1 ;z[n] = 0;c[n] = 0
#Paso 6 ----
for(j in (n-1):1){
c[j] = z[j] - (u[j]*c[j+1])
d[j] = (c[j+1] - c[j])/(3*h[j])
}
#interpolacion en el punto ----
for(i in 1:(n-1)) {
if(x[i]<= xk & x[i+1]>= xk){
s = i}
} #Nos fijamos a que polinomio pertenece el valor a interpolar
yk = fx[s]+b[s]*(xk-x[s])+c[s]*(xk-x[s])ˆ2+d[s]*(xk-x[s])ˆ3 #Lo valuamos en el polinomio correspondien
return(yk)
}
x=c(2.5,4.375,6.250,8.125,10.000,11.875,13.750,15.625 ,17.500)
fx=c(0.0013,0.0122,0.0668,0.2266,0.5000,0.7734,0.9332,0.9878,0.9987)
A=cbind(x,fx)
Ej.4.4 = Natural_Cubic_Spline_SinGraficar(A,12.61)
Ej.4.4
## [1] 0.8513667
4.5 Graficar
Grafique lo siguiente:
a. Datos dados en la tabla mediante puntos (círculos, rellenos o no).

b. Línea continua de color verde con la función PN (x) para x en [2.5; 17.5].
c. Línea continua de color azul con los trazadores cúbicos para x en [2.5; 17.5].
Respuesta:
23
# Grafico ----
plot(x,fx,pch = 21,cex=1.5,lwd=0.5,bg="black", ylim = c(-0.5,1.5), xlim = c(2.75,17.5))
#grafico PL
A=cbind(x,fx)
m=A[,1]
n=A[,2]
if(length(m)!=length(n)){
}
B=seq(m[1],m[length(m)],length.out = 1000) #los valores sobre los cuales se interpolará para graficar
Fx=c() #se genera el vector en el cual se guardan las interpolaciones
#Interpolo todos los valores para despues graficar
for(h in 1:length(B)){
interpolador=0
for(i in 1:length(m)){
u=1
v=1
l=n[i]
for(j in 1:length(m)){
if(i!=j){
u=u*(B[h]-m[j])
v=v*(m[i]-m[j])
l=l*(B[h]-m[j])/(m[i]-m[j])
}
}
interpolador=interpolador+l
}
Fx=c(Fx,interpolador) #se van guardando las interpolaciones
}
lines(B,Fx, col = "green")
# Grafico Trazador Cubic Splines ----

x=c(2.5,4.375,6.250,8.125,10.000,11.875,13.750,15.625 ,17.500)
fx=c(0.0013,0.0122,0.0668,0.2266,0.5000,0.7734,0.9332,0.9878,0.9987)
#para añadir al grafico el trazador voy a interpolar en 1000 puntos, usando como base la funcion que ten
x = A[,1]
fx = A[,2]
}
#Paso 1 y 2
for(i in 1:(n-1)){
h[i] = x[i+1]-x[i]
}
for(i in 2:(n-1)){
}
#Paso 3
l[1] = 1;u[1] = 0;z[1] = 0
#Paso 4
24
for(i in 2:(n-1)){
l[i] = 2*(x[i+1] - x[i-1]) - (h[i-1]*u[i-1])
u[i] = h[i]/l[i]
z[i] = (a[i]- h[i-1]*z[i-1])/l[i]
}
#Paso 5
l[n] = 1 ;z[n] = 0;c[n] = 0
#Paso 6
for(j in (n-1):1){
c[j] = z[j] - (u[j]*c[j+1])
d[j] = (c[j+1] - c[j])/(3*h[j])
}
B = seq(x[1],x[length(x)],length.out = 1000)
B2 = NULL
for(r in 1:1000){
for(i in 1:(n-1)){
if(x[i]<=B[r] & x[i+1]>= B[r]){
g = i
}
}
rk = fx[g]+b[g]*(B[r]-x[g])+c[g]*(B[r]-x[g])ˆ2+d[g]*(B[r]-x[g])ˆ3
B2 = c(B2,rk)
} #Interpolamos 1000 numeros para poder graficar
lines(B,B2, col = "blue")
1.5
1.0
0.5
fx
0.0
−0.5
5 10 15
25
5 Derivación Numérica (10 puntos)
Considere los datos de la tabla siguiente, donde P = f (r).
r P
0.00 110.0000
0.01 105.8529
0.02 101.9039
0.03 98.1415
0.04 94.5552
0.05 91.1351
0.06 87.8721
0.07 84.7575
0.08 81.7833
0.09 78.9418
0.10 76.2260
5.1 Estime P ′ (x).
Utilice el método de los 5 puntos centrados para aproximar P ′ (r0 ) y P ′ (r1 ). Si no pudiese aplicar el método,
explique por qué.
rm(list = ls())
graphics.off()
x = c(0.00,0.01,0.02,0.03,0.04,0.05,0.06,0.07,0.08,0.09,0.1)
y = c(110.0,105.8529,101.9039,98.1415,94.5552,91.1351,87.8721,84.7575,81.7833,78.9418,76.2260)
# 1) Cargo Algoritmo ----

derivada5ptos<-function(x, y, xindice, H = T, endpoint = F){
n = length(y)
yprima = c(rep(NA,n))
if(H == T){#If para fórmulas progresivas

h = diff(x)[1]
if(endpoint == F){
if(missing(xindice)){
for (i in 3:(n - 2)) {
yprima[i] = (y[i-2] - 8*y[i-1] + 8*y[i+1] - y[i+2])/(12*h)
}
tabla = cbind.data.frame(x, y, yprima)
return(tabla)
}
else{
if(xindice == n || xindice == n-1 || xindice == 1 || xindice == 2){
26
return("Este valor no se puede calcular")
}
else{
yprima[xindice] = (y[xindice-2] - 8*y[xindice-1] + 8*y[xindice+1] - y[xindice+2])/(12*h)
return(yprima[xindice])
}
}
}else{
for (i in 1:(n - 4)) {
yprima[i] = (-25*y[i] + 48*y[i+1] - 36*y[i+2] + 16*y[i+3] - 3*y[i+4])/(12*h)
}
return(tabla)
}
else{
if(xindice == n || xindice == n-1 || xindice == n-2 || xindice == n-3){
}
else{
yprima[xindice] = (-25*y[xindice] + 48*y[xindice+1] - 36*y[xindice+2] + 16*y[xindice+3] - 3*y[
}
}
}
}
else{#If para fórmulas regresivas
h = -diff(x)[1]
if(endpoint == F){
for (i in 3:(n - 2)) {
yprima[i] = (y[i+2] - 8*y[i+1] + 8*y[i-1] - y[i-2])/(12*h)
}
return(tabla)
}
else{
if(xindice == n || xindice == n-1 || xindice == 1 || xindice == 2){
}
else{
yprima[xindice] = (y[xindice+2] - 8*y[xindice+1] + 8*y[xindice-1] - y[xindice-2])/(12*h)
}
}
}else{
for (i in 5:n) {
yprima[i] = (-25*y[i] + 48*y[i-1] - 36*y[i-2] + 16*y[i-3] - 3*y[i-4])/(12*h)
}
return(tabla)
}
27
else{
if(xindice == 1 || xindice == 2 || xindice == 3 || xindice == 4){
}
else{
yprima[xindice] = (-25*y[xindice] + 48*y[xindice-1] - 36*y[xindice-2] + 16*y[xindice-3] - 3*y[
}
}
}
}
# El H indica que las formulas serán progresivas

# H = F las formulas serán regresivas.
# El parámetro, por defecto como FALSE, endpoint indica si la formula es con punto medio
#o punto extremo (endpoint = T)
# 2) Corro para los puntos ----

derivada5ptos(x, y, 8, H = T, endpoint = F)
## [1] -304.3092
derivada5ptos(x, y, 2, H = T, endpoint = F)
## [1] "Este valor no se puede calcular"
#El metodo de los 5 puntos tiene dos formulas:

#Midpoint: Tomará (x0 -2h) (x0-h) (x0+h) y (x0 +2h).
#Es decir, si estoy en x0 necesitaré los 2 valores anteriores y los dos posterios.
#En este caso es posible calcularlo porque contamos con los valores requeridos por la formula
#Endpoint: En caso de ser progresiva, por ejemplo, tomará
#(x0) (x0 +h) (x0 +2h)(x0 +3h)(x0 +4h). Es decir, si estoy en x0 necesitaré los siguientes 4 puntos.
#Derivada 5 puntos: 0.07 -> es posible calcularlo porque contamos con los valores requeridos por la form
#Derivada 5 puntos:0,10 -> No es posible calcularlo, me falta (x0-2h)
5.2 Estime P ′′ (x).
Aproxime la derivada segunda P ′′ (r0 ). Si no pudiese aproximarla, explique por qué.
#No em fue posible calcular la segunda derivada. ENtiendo que la funcion no esta definida en x0-h
28
6 SQL (10 puntos)
Utilice la base de datos de la siguiente web para preparar sus códigos de SQL: https://www.w3schools.com/
sql/trysql.asp?filename=trysql_select_all
6.1 Consulta empleados
Escriba una consulta SQL que contenga una comisión del 20% para los empleados que realizaron ventas por
más de $ 80.000, del 10% para los que tuvieron ventas mayores o iguales a $ 40.000 y menores a $ 80.000 y
del 5% para los que vendieron más de $ 30.000 y menos de $ 40.000. La salida debe contener los siguientes
campos: Nombre y Apellido del Vendedor, Cantidad de ventas, Total vendido ($), Comisión (%).
SELECT DISTINCT E.LastName ||’ ‘|| E.FirstName as ’Nombre y Apellido’, COUNT(DISTINCT
O.OrderID) as Ventas, ROUND(SUM(P.PriceD.Quantity),2) as TotalVendido, CASE WHEN SUM(P.Price(D.Quantity))
> 80000 THEN ‘20%’ WHEN SUM(P.Price(D.Quantity)) BETWEEN 40000 and 80000 THEN ‘10%’
WHEN SUM(P.Price(D.Quantity)) < 80000 THEN ‘5%’ ELSE ‘0%’ END as ComisionPorc FROM
Employees E LEFT JOIN Orders O ON E.EmployeeID = O.EmployeeID LEFT JOIN OrderDetails D
ON O.OrderID = D.OrderID LEFT JOIN Products P ON D.ProductID = P.ProductID GROUP BY
E.EmployeeID
6.2 Consulta Clientes
Escriba una consulta SQL que contenga los clientes que hicieron más de 5 compras o gastaron más de $
30.000 en el total de todas sus compras. La salida debe contener los siguientes campos: Nombre del Cliente,
Nombre del Contacto, ciudad y país del cliente, Cantidad de compras, Total (calculado como la suma total
del Precio*Cantidad).
SELECT C.CustomerName as ‘Nombre Cliente’, C.ContactName as ‘Nombre del Contacto’, C.City as Ciu-
dad, C.Country as Pais, COUNT(DISTINCT O.OrderID) AS Compras, ROUND(SUM(P.Price*D.Quantity),2)
as Total FROM Customers AS C INNER JOIN Orders O ON C.CustomerID = O.CustomerID INNER JOIN
OrderDetails D ON O.OrderID = D.OrderID INNER JOIN Products P ON D.ProductID = P.ProductID
GROUP BY C.CustomerName HAVING Total > 30000 OR Compras > 5
29

Examen Final - Análisis Numérico (Uba Fce)

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Examen Final - Análisis Numérico (Uba Fce)

Cargado por

Copyright:

Formatos disponibles

Económicas, UBA. Actuario. Análisis Numérico.

Cuatrimestre 1, 2021. Examen FINAL.

Remplace este texto por su Apellido y Nombre, y su Numero de Registro.

2 Integral Densidad Beta (20 puntos) 7

3 Integración y Derivación Numérica (20 puntos) 15

4 Interpolación (20 Puntos) 18

6 SQL (10 puntos) 29

1.1 Graficar la función

g <- function(x){ # Funcion g(x) para la iteracion de punto fijo

plot(g,pch = 21,cex=1.5,lwd=0.5,bg="black", ylim = c(-1,1), xlim = c(-1,1))

−1.0 −0.5 0.0 0.5 1.0

1.2 Corregir algoritmo

CORREGIR el algoritmo “PuntoFijo” en el siguiente bloque de código.

PuntoFijo <- function(g,p0,Tol,N){

PF = PuntoFijo(g,0, 0.001, 10000)

Raiz_1 <- PuntoFijo(g,0, 0.001, 10000)

−1.0 −0.5 0.0 0.5 1.0

1.4 Graficar los puntos fijos

2.1 Estimación de Función Gamma

xio = fn(a) + fn(b)

# 2) Defino variables ----

0.0 0.2 0.4 0.6 0.8 1.0

0.0 0.2 0.4 0.6 0.8 1.0

0.0 0.2 0.4 0.6 0.8 1.0

0.0 0.2 0.4 0.6 0.8 1.0

2.2 Simpson y Trapecio

2.3 Esperanza Matemática

(max1 = optimize(g_d4_v2,c(0.5,1.5),maximum = T))

## Warning in optimize(g_d4_v2, c(0.5, 1.5), maximum = T): NA/Inf replaced by

0.0 0.5 1.0 1.5 2.0

## [1] "Cota de error= 7.0721e-11"

2.4 Esperanza Matemática de una función condicional

0.0 0.2 0.4 0.6 0.8 1.0

#Caluclo la esperanza por

print(paste("La esperanza condicionada es=",round(RDO,4)))

## [1] "La esperanza condicionada es= 0.1677"

simpson.compuesto = function(a, b, n){

print(paste("La esperanza será",round(Rdo,4)))

## [1] "La esperanza será 29.2664"

3.2 Derivada respecto a µ

Estime numéricamente la derivada de E(S|µ; σ) respecto del parámetro µ.

Estime numéricamente la derivada de E(S|µ; σ) respecto del parámetro σ.

3.4 Función E(S|µ; σ) = f (σ)

4.1 Polinomio de Newton: PN (x)

#Cargo Diferencias Divididas ----

Ej.4.1_Escribe_Newton = e #este es el Polinomio de Lagrange escrito mediante la forma de diferencias div

## expression(‘f(x)‘ = 0.0013 + 1 * (x - 2.5) * 0.00581333333333333 +

#Dos formas de resolverlo:

#Segundo, modificando el algoritmo para uqe solo interpole

# Interpola en un punto dado ----

4.3 Cubic Splines: Si (x)

4.4 Interpolar con Si (x)

Usando los trazadores cúbicos, interpole los datos para el valor x = x0 .

#Segunda, modificando el algoritmo para que solo interpole:

a. Datos dados en la tabla mediante puntos (círculos, rellenos o no).

# Grafico Trazador Cubic Splines ----

5.1 Estime P ′ (x).

# 1) Cargo Algoritmo ----

if(H == T){#If para fórmulas progresivas

# El H indica que las formulas serán progresivas

# 2) Corro para los puntos ----

## [1] "Este valor no se puede calcular"

#El metodo de los 5 puntos tiene dos formulas: