ExDecaiEulerMin28-01-21, R

Language: Layout:

# Gráfico em 3 dimensões

# Resolver a equação f(x,y)=(f1(x,y),f2(x,y))=(0,0).

f1<-function(u){   # Definição de f1
x=u[1]
y=u[2]
f1=y*x^3+y^4+2*x*y+x+y+1 
f1 
}

print("Teste de f1:"); f1(c(1,2))

f2<-function(u){   # Definição de f1
x=u[1]
y=u[2]
f2=y*x^2+2*x*y+x+5
f2
}

print("Teste de f2:"); f2(c(1,2))

f<-function(u){   # Definição de f=(f1,f2)
c(f1(u),f2(u))
}

print("Teste de f:"); f(c(1,2))

x <- seq(-5,2, by=0.05)    # Malha para gráficos
y <- seq(-2,2,by=0.05)

mf<-function(s,r){   # Definição de mf=|f|^2; com coordenadas para gráfico
u=c(s,r)
f1(u)^2+f2(u)^2 
}

print("Teste de |f|^2:"); mf(1,2)

require(grDevices) # for trans3d
z <- outer(x, y, mf)
z[is.na(z)] <- 4
op <- par(bg = "white")
persp(x, y, z, theta = 60, phi = 20, expand = 1)
contour(x,y,z,levels=c(0.5,1,5,10))

#
persp(x, y, z, theta = 60, phi = 20, expand = 1)->res

# Método de Euler para resolver a equação u'(t)=-grad f(u(t)), e(0)=(2,-2)

gradmf<-function(u){ # gradiente de f(x,y)
s=u[1]
r=u[2]
h=10^(-5)
dnfx= mf(s+h,r)-mf(s-h,r)
dnfy=mf(s,r+h)-mf(s,r-h)
c(dnfx,dnfy)/(2*h)
}

t0=0  # tempo inicial
tf=1  # t final 
e0=c(2,-2) # condição inicial 
mf(e0[1],e0[2]) # teste da escolha
n=5000
h=(tf-t0)/n  # Tamanho do passo

tt=seq(t0,tf,by=h)

Y=matrix(0,2,length(tt))
Y[,1]=e0

for ( i in 1:(length(tt)-1)){
Y[,i+1]=Y[,i]-h*gradmf(Y[,i])
}

print("Aproximação para o ponto de mínimo"); Y[,length(tt)]
print("Aproximação para o valor mínimo"); mf(Y[1,length(tt)],Y[2,length(tt)])

lines(trans3d(Y[1,],Y[2,],mf(Y[1,],Y[2,]), res), col = "blue", lwd = 2) # Inclui curvas

plot(Y[1,],Y[2,],col="blue")

plot(tt,mf(Y[1,],Y[2,]), col = "blue")

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

Jacf<-function(u){ # Jacobiano de f(x,y)
s=u[1]
r=u[2]
h=10^(-5)

dfx= f(s+h,r)-f(s-h,r)
dfy=f(s,r+h)-f(s,r-h)
A=matrix(0,2,2)
A[1,]=dfx; A[2,]=dfy
A/(2*h)
}

Jacf(c(1,2))

iJacf<-function(u){ # inversa do jacobiano  de f(x,y) (caso 2x2)
A=Jacf(u); B=0*A
d=A[1,1]*A[2,2]-A[1,2]*A[2,1] # determinante
B[1,1]=A[2,2]; B[1,2]=-A[2,1]; B[2,1]=-A[1,2]; B[2,2]=A[1,1]
t(B)/d
}

iJacf(Y[,length(tt)])

iJacf(c(1,2))%*%Jacf(c(1,2))

iJacf(c(1,2))%*%f(1,2)

alpha<-function(u){min(eigen(t(Jacf(u))%*%Jacf(u))$values)}

alpha0=0*tt
for ( i in 1:length(tt)){
alpha0[i]=alpha(Y[,i])}

alpha1=min(alpha0)

points(tt,mf(Y[1,1],Y[2,1])*exp(-sqrt(alpha1)*tt), col = "red",xlim=c(0,1))

plot(tt,sqrt(alpha0), col = "green")

# --------------------------- Euler

t0=0  # tempo inicial
tf=1  # t final 
e0=c(2,-2) # condição inicial 
mf(e0[1],e0[2]) # teste da escolha
n=5000
h=(tf-t0)/n  # Tamanho do passo

tt=seq(t0,tf,by=h)

Y=matrix(0,2,length(tt))
Y[,1]=e0

for ( i in 1:(length(tt)-1)){
Y[,i+1]=Y[,i]-h*t(Jacf(Y[,i]))%*%f(Y[1,i],Y[2,i])
}

print("Aproximação para o ponto de mínimo"); Y[,length(tt)]
print("Aproximação para o valor mínimo"); mf(Y[1,length(tt)],Y[2,length(tt)])

plot(Y[1,],Y[2,],col="blue")

plot(tt,mf(Y[1,],Y[2,]), col = "blue")

points(tt,mf(Y[1,1],Y[2,1])*exp(-sqrt(alpha1)*tt), col = "red",xlim=c(0,1))

# ---------------------------Euler---->Newton

t0=0  # tempo inicial
tf=10  # t final 
e0=c(2,-2) # condição inicial 
mf(e0[1],e0[2]) # teste da escolha
n=10
h=(tf-t0)/n  # Tamanho do passo

tt=seq(t0,tf,by=h)

Y=matrix(0,2,length(tt))
Y[,1]=e0

for ( i in 1:(length(tt)-1)){
Y[,i+1]=Y[,i]-h*iJacf(Y[,i])%*%f(Y[1,i],Y[2,i])
}

print("Aproximação para o ponto de mínimo"); Y[,length(tt)]
print("Aproximação para o valor mínimo"); mf(Y[1,length(tt)],Y[2,length(tt)])

plot(Y[1,],Y[2,],col="blue")

plot(tt,mf(Y[1,],Y[2,]), col = "blue")

[ + ] Show input
Absolute running time: 0.41 sec, cpu time: 0.66 sec, memory peak: 43 Mb, absolute service time: 0,61 sec