resumo p3

Esta é uma pré-visualização de arquivo. Entre para ver o arquivo original

############################
# APROXIMACAO DE FUNCOES
############################
#options(digits = 21)
round(((0.47*4.2)+43.25), digits = 2)
# EXPONENCIAL
pol_exp_delta = function(x,delta = 0.001){
 if(!is.numeric(x)) stop("x tem que ser real")
 soma = 1
 for(i in 1:10){
 soma = soma + x^(i)/factorial(i)
 }
 i = 11
 while(TRUE){
 incre = x^(i)/factorial(i)
 
 if(abs(incre) < delta){
 return(soma)
 }else{
 soma = soma + incre
 }
 
 i = i + 1
 }
}
pol_exp_delta(1/2)
# LN
pol_ln_delta = function(x,delta = 0.001){
 if(x<=0) stop("X precisa ser maior que 0")
 if(!is.numeric(x)) stop("x tem que ser real")
 if(x>=2) return(-pol_ln_delta(1/x,delta))
 
 soma = 0
 for(i in 0:10){
 soma = soma + ((-1)^i) * (((x-1)^(i+1))/(i+1))
 }
 i = 11
 
 while(TRUE){
 incre = ((-1)^i) * (((x-1)^(i+1))/(i+1))
 
 if(abs(incre) < delta){
 return(soma)
 }else{
 soma = soma + incre
 }
 
 i = i + 1
 }
}
# LOG_A(B)
aprox_ln_base = function(x,b,delta = 0.001){
 return(pol_ln_delta(x,delta)/pol_ln_delta(b,delta))
}
aprox_ln_base(100,10)
# RECURSIVAMENTE SEM USAR A FUNCAO JA FEITA
# SEN(X)
aprox_sen = function(x,delta = 0.001){
 if(x > pi) return(aprox_sen(x - 2*pi, delta))
 if(x < -pi) return(aprox_sen(x + 2*pi, delta))
 
 soma = 0
 for(i in 0:10){
 soma = soma + ((-1)^(i))*(x^(2*i + 1))/factorial(2*i + 1)
 }
 
 i = 11
 
 while(TRUE){
 incre = ((-1)^(i))*(x^(2*i + 1))/factorial(2*i + 1)
 if(abs(incre) < delta){
 return(soma)
 }else{
 soma = soma + incre
 }
 i = i + 1
 }
}
# COS(X)
aprox_cos = function(x, delta = 0.001){
 return(aprox_sen(x + pi/2, delta))
}
############################
# RAIZES DE FUNCOES REAIS
############################
# NAO RECURSIVO
RaizBissecao = function(a,b,f,e){
 if(f(a)*f(b) >= 0) stop("Não existe raiz no intervalo a,b")
 
 while(TRUE){
 m = (a+b)/2
 
 if(f(m) == 0 | abs(b-m) < e) return(m)
 
 if(f(a)*f(m) < 0){
 b = m
 }else{
 a = m
 }
 }
}
RaizBissecao(0,3,f=function(x){x-1},0.000001)
# RECURSIVO
RaizBissecaoRec = function(a,b,f,e){
 if(f(a)*f(b) >= 0) stop("Não existe raiz no intervalo a,b")
 
 m = (a+b)/2
 
 if(f(m) == 0 | abs(b-m) < e) return(m)
 if(f(a)*f(m) < 0) return(RaizBissecaoRec(a,m,f,e))
 
 return(RaizBissecaoRec(m, b, f, e))
}
RaizBissecaoRec(0,3,f=function(x){x-1},0.000001)
# COM ARRAY
RaizBissecaoArray = function(a,b,f,e){
 if(f(a)*f(b) >= 0) stop("Não existe raiz no intervalo a,b")
 aproximacoes = c()
 while(TRUE){
 m = (a+b)/2
 
 if(f(m) == 0 | abs(b-m) < e) {
 aproximacoes = c(aproximacoes,m)
 return(aproximacoes)
 }
 if(f(a)*f(m) < 0){
 b = m
 aproximacoes = c(aproximacoes,m)
 }else{
 a = m
 aproximacoes = c(aproximacoes,m)
 }
 }
}
# RAIZ QUADRADA
aproxRaiz = function(x0,e = 0.00000000001){
 if(x0 < 0) stop("Não existe raiz de número negativo")
 
 if(x0 == 1 | x0==0) return(x0)
 
 if(x0 > 1) b = x0
 else b = 1
 
 return(RaizBissecao(0,b,function(x){x^2-x0},e))
}
############################
# DERIVACAO NUMERICA
############################
# DOMINIO DA FUNCAO
f = function(x){
 if(!(x < -2 | x > 1)) return(FALSE) #Fora do domínio
 else return(log(x^2 + x - 2))
}
# USANDO ISSO NA DERIVACAO
DerivadaNumerica = function(x0,f,delta = 0.001){
 h = 1
 d1 = (f(x0+h) - f(x0-h))/(2*h)
 while(!d1){ #AQUI VAI RETORNAR F SE ESTIVER FORA DO DOMINIO
 h = h/2
 d1 = (f(x0+h) - f(x0-h))/(2*h)
 }
 
 while (TRUE) {
 h = h/2
 d2 = (f(x0+h) - f(x0-h))/(2*h)
 if(abs(d1-d2) < delta) return(d2)
 d1 = d2
 }
}
DerivadaNumerica(10,f)
############################
# INTEGRACAO NUMERICA
############################
# SOMA POR RETANGULOS
soma_ratangulo = function(n,inicio,fim){
 base = fim - inicio
 acrescimo = base/n
 vet = c()
 for(i in 1:n){
 vet = c(vet,i*acrescimo)
 }
 
 soma = f(inicio)*acrescimo
 
 for(i in vet[-length(vet)]){
 altura = f(i)
 base = acrescimo
 soma = base*altura + soma
 }
 
 return(soma)
}
# INTEGRAL
IntegralDominioReal = function(a,b,f,e = 0.001){
 n = 100
 
 while(TRUE){
 d = (b-a)/n
 A_S = 0 ; A_I = 0
 
 
 x = a
 
 while(x < b){
 A_S = A_S + d*max(f(x),f(x+d))
 A_I = A_I + d*min(f(x),f(x+d))
 x = x + d
 }
 if((A_S - A_I) < 2*e) return((A_S+A_I)/2) 
 else n = n + 10
 }
} 
IntegralDominioReal(a = 0, b = 5,f)
# INTEGRAL COM RECURSAO
IntegralDominioRealRec = function(f,a,b,e = 0.001, n = 100){
 
 d = (b-a)/n
 A_S = 0 ; A_I = 0
 
 x = a
 
 while(x < b){
 A_S = A_S + d*max(f(x),f(x+d))
 A_I = A_I + d*min(f(x),f(x+d))
 x = x + d
 }
 
 if((A_S - A_I) < 2*e) return((A_S+A_I)/2)
 else return(IntegralDominioRealRec(f,a,b,e,n+10))
}
IntegralDominioRealRec(f,a = 0,b = 5)