%diferencias divididas con funcion
disp('-.Método de
diferencias divididias.-')
X=input('Introduzca
los valores de X [xo,x1,x2,...,x3]: ');
syms x
f=input('Introduzca la
funcion f(x): ');
pto=input('Introduzca el
punto a aproximar: ');
Y=subs(f,X);
n=length(X);
Q=zeros(n,n);
Q(:,1)=Y';
c=2;
k=1;
for j=2:1:n
for i=c:1:n
Q(i,j)=(Q(i,j-1)-Q(i-1,j-1))/(X(i)-X(i-k));
end
k=k+1;
c=c+1;
end
fprintf('\nLa matriz Q
es: \n')
disp(Q)
fprintf('\nEl
polinomio P es: \n')
syms x
c=1;
prod=1;
P=Q(1,1);
for N=2:1:n
for i=1:1:c
prod=prod*(x-X(i));
end
c=c+1;
P=P+prod*Q(N,N);
prod=1;
end
pretty(P)
valor_aprox=subs(P,pto);
valor_exacto=subs(f,pto);
resta=abs(valor_aprox-valor_exacto);
fprintf('\nEl valor
aproximado es: %9.9f',valor_aprox)
fprintf('\nEl valor
exacto es: %9.9f',valor_exacto)
fprintf('\nEl error
entre las cifras es: %e',resta)
fprintf('\n')
%METODO DE HERMIT DE
DIFERENCIAS DIVIDAS
%Pasar a fraccion, Hacer la
primera columna (Z)
fprintf('\n');
clear all
clc
fprintf('
-----------------------------------------\n')
fprintf(' MÉTODO DE HERMIT DE
DIFERENCIAS DIVIDIDAS\n')
fprintf('
-----------------------------------------\n')
fprintf('\n');
syms x
r=input('- Defina la
función : ');
xi=input('- Introduzca
los valores de x : ');
y=input('- Introduzca
los valores de y : ');
yderiv=input('- Introducir
los valores de la derivada : ');
k=input('- Introduzca
el valor a aproximar : ');
fprintf('\n' );
fprintf('\n' );
n=2*length(xi);
D=zeros(n,n);
b=1;
for a=1:2:n
z(a)=xi(b);
z(a+1)=xi(b);
y2(a)=y(b);
y2(a+1)=y(b);
b=b+1;
end
D(:,1)=y2';
x=0;
j=0;
cont=1;
while j<n-1
x=x+1;
j=j+1;
for i=x:n-1
if (z(i+1)-z(i+1-j))==0
D(i+1,j+1)=yderiv(cont);
cont=cont+1;
else
D(i+1,j+1)=(D(i+1,j)-D(i,j))/(z(i+1)-z(i+1-j));
end
end
end
D
s=1;
c=0;
q=0;
p=0;
for i=2:n
for j=i
s=1;
for m=1:1
q=q+1;
for h=1:(i-1)
s=s*(k-z(i-q));
q=q-1;
end
p=p+1;
q=q+p;
end
end
c=c+(D(i,j)*s);
end
for i=1:1
for j=i
c=c+(D(i,j));
end
end
fprintf('\n');
fprintf('- El
resultado es : %10.8f\n',c);
fprintf('\n');
d=subs (r,k);
fprintf('- La función
evaluada es : %10.8f\n',d);
fprintf('\n');
w=abs(d-c);
fprintf('- El
porcentaje de error es : %10.8f\n',w);
fprintf('\n');
%METODO DE DIFERENCIAS
DIVIDAS
fprintf('\n');
clear all
clc
fprintf('
-------------------------------\n')
fprintf(' MÉTODO DE
DIFERENCIAS DIVIDIDAS con funcion\n')
fprintf('
-------------------------------\n')
fprintf('\n');
syms x
r=input('- Defina la
función : ');
X=input('- Introduzca
los valores de x : ');
Y=input('- Introduzca
los valores de y : ');
z=input('- Introduzca
el valor a aproximar : ');
n=length(X);
D=zeros(n,n);
D(:,1)=Y';
for j=2:n
for k=j:n
D(k,j)=(D(k,j-1)-D(k-1,j-1))/(X(k)-X(k-j+1))
end
end
s=1;
c=0;
q=0;
p=0;
for k=2:n
for j=k
s=1;
for m=1:1
q=q+1;
for h=1:(k-1)
s=s*(z-X(k-q));
q=q-1;
end
p=p+1;
q=q+p;
end
end
c=c+(D(k,j)*s);
end
for k=1:1
for j=k
c=c+(D(k,j));
end
end
fprintf('\n');
fprintf('- El
resultado es : %10.8f\n',c);
fprintf('\n');
d=subs (r,z);
fprintf('- La función
evaluada es : %10.8f\n',d);
fprintf('\n');
w=abs(d-c);
fprintf('- El
porcentaje de error es : %10.8f\n',w);
fprintf('\n');
%método neville
disp('Metodo de
Neville')
disp('Recuerde que
no hay funcion, debe de ingresar los datos con la funcion ya evaluada')
po=input('Ingrese el
número a evaluar: ');
n=input('Ingrese el
número de datos: ');
%creo las variables en que
se almacenara los datos
x=zeros(1,n);
f=zeros(1,n);
Q=zeros(n-1,n-1);
%Pido los datos de entrada
for i=1:n
fprintf('Ingrese el valor de x%d: ',i-1);
x(i)=input('');
fprintf('Ingrese el valor de f(x%d): ',i-1);
f(i)=input('');
end
%comienzo a evaluar los
datos
%se crean los Q(x,y)
for l=1:n-1
for m=l:n-1
%El if
esta xq si l>1 ya no se usan los valores de F(xi) sino que se usan los
valores previamente obtenidos de Q
if l==1
%Calculo el valor de Q(x,y) y la
Ec. la coloco en pantalla
Q(m,l)=((po-x(m))*f(m+1)-(po-x(m+1))*f(m))/(x(m+1)-x(m));
fprintf('\nQ[%d,%d]=
(X-X(%d))Q[%d,%d]-(X-X(%d))Q[%d,%d])',m,l,m-1,m,l-1,m,m-1,l-1);
fprintf('\n-------------------------------------------- =
%.9f',Q(m,l));
fprintf('\n\t\t\tX(%d)-X(%d)\n',m,m-1);
else
%Calculo el valor de Q(x,y) y la
Ec. la coloco en pantalla
Q(m,l)=((po-x(m-l+1))*Q(m,l-1)-(po-x(m+1))*Q(m-1,l-1))/(x(m+1)-x(m-l+1));
fprintf('\nQ[%d,%d]= (X-X(%d))Q[%d,%d]-(X-X(%d))Q[%d,%d])',m,l,m-l,m,l-1,m-1,m-1,l-1);
fprintf('\n-------------------------------------------- =
%.9f',Q(m,l));
fprintf('\n\t\t\tX(%d)-X(%d)\n',m,m-l);
end
end
end
fprintf('\n\nEl valor
aproximado de x es: %.9f\n\n',Q(n-1,n-1));
fprintf('\n\nEl valor
aproximado de x es: %.9e\n\n',Q(n-1,n-1));
% metodo de lagrange
disp('Metodo de
Interpolacion y Polinomio de Lagrage - Sin usar funcion.');
syms x;
disp('RECUERDE
TODOS LOS DATOS DEBEN DE ESTAR EN LA MISMA ESCALA');
fprintf('P(x):f(x0)*L0(x)+f(x1)L1(x)....\n');
fprintf('L0(x)=(x-x1)(x-x2)(x-x3)/(x0-x1)(x0-x2)(x0-x3)....\n');
po=input('Ingrese el
número a evaluar: ');
n=input('Ingrese el
número de datos: ');
%creo las variables en que
se almacenara los datos
puntos=zeros(1,n);
valores=zeros(1,n);
EcLagrange=0;
%'La' representa el
numerador de cada polinimo L(x) y 'Lb' representa el denominador
La=1;
Lb=1;
L=zeros(1,n);
%Pido los datos de entrada
for i=1:n
fprintf('Ingrese el valor de x%d: ',i-1);
puntos(i)=input('');
fprintf('Ingrese el
valor de f(x%d): ',i-1);
valores(i)=input('');
end
for i=1:n
for j=1:n
if j~=i
%Generamos el numerador y
denominador del polinomio
La=La*(x-puntos(j));
Lb=Lb*(puntos(i)-puntos(j));
end
end
%imprimimos la formula en pantalla
fprintf('L%d(x)=\n',i-1);
pretty(La/Lb);
fprintf('\n--------------------------------------------------------------------------------\n\n');
%Evaluamos la funcion
funcion=La/Lb;
%creamos el polinomio de lagrange.
EcLagrange=EcLagrange+funcion*valores(i);
L(i)=subs(po,funcion);
La=1;
Lb=1;
end
fprintf('Polinomio de Lagrange:\n');
pretty(EcLagrange);
resultado=subs(EcLagrange,po);
fprintf('\n\nEl valor
del polinomio evaluado en %f es de: %.8f\n',po,resultado);
prueba
ResponderEliminar***********************************************************************************
ResponderEliminar********** DIFERENCIAS DIVIDIDAS(solo tabla sin funcion)****************
***********************************************************************************
function diferenciasdivididas()
clear all;
clc;
disp('Método de interpolación de diferencias divididas de Newton');
syms x;
y=input('Ingrese el número a evaluar: ');
n=input('Ingrese el número de datos: ');
%creo las variables en que se almacenara los datos
%recordar que para una matrix M(x,y) el orden es M(fila , columna)
xi=zeros(1,n);
dif=zeros(n,n);
polinomio=0;
factor=1;
%Pido los datos de entrada
for k=1:n
fprintf('Ingrese el valor de x%d: ',k-1);
xi(k)=input('');
fprintf('Ingrese el valor de f(x%d): ',k-1);
dif(k,1)=input(''); %me desplazo en las filas
if k==1
polinomio=polinomio+dif(k,1);
end
end
for l=2:n
for m=l:n
dif(m,l)=(dif(m,l-1)-dif(m-1,l-1))/(xi(m)-xi(m-l+1));
%se entra al loop al inicio para tener todos los factores (x-xn)
%en cada iteracion
if m==l
for t=1:l-1
% en la variable vamos a ir guardando la expresión (x - x0)(x - x1)...
% (x - xn)
factor=factor*(x-xi(t));
end
%Se agrega el contenido de factores y guardamos el polinomio final
polinomio=polinomio+(dif(m,l)*factor);
factor=1;
end
end
end
fprintf('Opciones:\n1) Respuestas en escritura normal\n2) Respuestas en notación científica\n');
t=1;
p=1;
while t==1
op=input('Ingrese la opción: ');
switch op
case 1
for l=1:n
fprintf('\n%.8f\t\t%.8f\t\t',xi(l),dif(l,1));
for m=2:p
fprintf('%.8f\t\t',dif(l,m));
end
p=p+1;
end
t=0;
case 2
for l=1:n
fprintf('\n%.8E\t\t%.8E\t\t',xi(l),dif(l,1));
for m=2:p
fprintf('%.8E\t\t',dif(l,m));
end
p=p+1;
end
t=0;
otherwise
disp('Opción incorrecta');
t=1;
end
end
fprintf('\n\nP(x)=\n');
pretty(polinomio);
a=subs(polinomio,y);
fprintf('\n\nEl valor de P(%f) es: %.10f\n\n',y,a);
*************************************************************************************
ResponderEliminar**************DIFERENCIASDIVIDIDASCONFUNCION************************
************************************************************************************
function diferenciasdivididas2()
disp('Método de interpolación de diferencias divididas de Newton');
y=input('Ingrese el número a evaluar: ');
syms x
f=input('Ingrese la función: ');
n=input('Ingrese el número de datos: ');
xi=zeros(1,n);
dif=zeros(n,n);
px=0;
Lnk=1;
for k=1:n
fprintf('Ingrese el valor de x%d: ',k-1);
xi(k)=input('');
dif(k,1)=subs(f,xi(k));
if k==1
px=px+dif(k,1);
end
end
syms x
for l=2:n
for m=l:n
dif(m,l)=(dif(m,l-1)-dif(m-1,l-1))/(xi(m)-xi(m-l+1));
if m==l
for t=1:l-1
Lnk=Lnk*(x-xi(t));
end
px=px+(dif(m,l)*Lnk);
Lnk=1;
end
end
end
fprintf('Opciones:\n1) Respuestas en escritura normal\n2) Respuestas en notación científica\n');
t=1;
p=1;
while t==1
op=input('Ingrese la opción: ');
switch op
case 1
for l=1:n
fprintf('\n%.10f\t\t%.10f\t\t',xi(l),dif(l,1));
for m=2:p
fprintf('%.10f\t\t',dif(l,m));
end
p=p+1;
end
t=0;
case 2
for l=1:n
fprintf('\n%.10E\t\t%.10E\t\t',xi(l),dif(l,1));
for m=2:p
fprintf('%.10E\t\t',dif(l,m));
end
p=p+1;
end
t=0;
otherwise
disp('Opción incorrecta');
t=1;
end
end
fprintf('\n\nP(x)=\n');
pretty(px);
a=subs(px,y);
fprintf('\n\nEl valor de P(%f) es: %.10f\n',y,a);
b=subs(f,y);
fprintf('El valor de f(%f) es: %.10f\n',y,b);
error=abs(a-b);
fprintf('El margen de error es de: %.3E\n\n',error);
*************************************************************************************
ResponderEliminar******************DIFERENCIADIVIDIDASSINFUNCION*********************
*************************************************************************************
function diferenciasdivididas()
clear all;
clc;
disp('Método de interpolación de diferencias divididas de Newton');
syms x;
y=input('Ingrese el número a evaluar: ');
n=input('Ingrese el número de datos: ');
%creo las variables en que se almacenara los datos
%recordar que para una matrix M(x,y) el orden es M(fila , columna)
xi=zeros(1,n);
dif=zeros(n,n);
polinomio=0;
factor=1;
%Pido los datos de entrada
for k=1:n
fprintf('Ingrese el valor de x%d: ',k-1);
xi(k)=input('');
fprintf('Ingrese el valor de f(x%d): ',k-1);
dif(k,1)=input(''); %me desplazo en las filas
if k==1
polinomio=polinomio+dif(k,1);
end
end
for l=2:n
for m=l:n
dif(m,l)=(dif(m,l-1)-dif(m-1,l-1))/(xi(m)-xi(m-l+1));
%se entra al loop al inicio para tener todos los factores (x-xn)
%en cada iteracion
if m==l
for t=1:l-1
% en la variable vamos a ir guardando la expresión (x - x0)(x - x1)...
% (x - xn)
factor=factor*(x-xi(t));
end
%Se agrega el contenido de factores y guardamos el polinomio final
polinomio=polinomio+(dif(m,l)*factor);
factor=1;
end
end
end
fprintf('Opciones:\n1) Respuestas en escritura normal\n2) Respuestas en notación científica\n');
t=1;
p=1;
while t==1
op=input('Ingrese la opción: ');
switch op
case 1
for l=1:n
fprintf('\n%.8f\t\t%.8f\t\t',xi(l),dif(l,1));
for m=2:p
fprintf('%.8f\t\t',dif(l,m));
end
p=p+1;
end
t=0;
case 2
for l=1:n
fprintf('\n%.8E\t\t%.8E\t\t',xi(l),dif(l,1));
for m=2:p
fprintf('%.8E\t\t',dif(l,m));
end
p=p+1;
end
t=0;
otherwise
disp('Opción incorrecta');
t=1;
end
end
fprintf('\n\nP(x)=\n');
pretty(polinomio);
a=subs(polinomio,y);
fprintf('\n\nEl valor de P(%f) es: %.10f\n\n',y,a);
*******************************************************************************************
ResponderEliminar***********DIFERENCIASDIVIDIDASSINFUNCIONversioncorta*****************
*******************************************************************************************
% Ingresar los vectores en formas de vector
X=input('- Introduzca los valores de x : ');
Y=input('- Introduzca los valores de y : ');
z=input('- Introduzca el valor a aproximar : ');
n=length(X);
D=zeros(n,n);
D(:,1)=Y';
for j=2:n
for k=j:n
D(k,j)=(D(k,j-1)-D(k-1,j-1))/(X(k)-X(k-j+1));
end
end
D
syms x
p = D(1,1) + D(2,2)*(x - X(1)) + D(3,3)*(x - X(1))*(x - X(2)) + D(4,4)*(x - X(1))*(x-X(2))*(x-X(3)) + ...
D(5,5)*(x - X(1))*(x-X(2))*(x-X(3))*(x-X(4)) + D(6,6)*(x - X(1))*(x-X(2))*(x-X(3))*(x-X(4))*(x-X(5))
aprox = subs(p,x,z);
fprintf('El valor aproximado es: %.15f\n\n',aprox)
**************************************************************************************
ResponderEliminar********************NEVILLE CON Y SIN FUNCION****************************
**************************************************************************************
clc;
syms x fx
fprintf('-----------------------------------------------------------------------\n');
disp(' METODO DE NEVILLE');
fprintf('\n-----------------------------------------------------------------------\n');
fprintf('---------PARAMETROS DE ENTRADA-------------------------------------------\n');
vx=input('Introduzca el valor de P(?) ==>');
xi=input('Introduzca los valores de [X0 ..... Xn] ==>');
n=length(xi);
p_g=input('Conoce la funcion f(x) Si-->1 ó No-->0 ==>');
if p_g==1
f=input('Ingrece la funcion f(x) ==> ');
%fprintf('\n\t--Evaluando la funcion en [xo,...xn]------\n');
%fprintf('\n');
for i=1:n
fx(i)=subs(f,xi(i));
%fprintf('F(%3.9f)=%3.9f\n',xi(i),fx(i));
end
else
fx=input('Ingrece los valores de Fx [F(xo),...,f(xn)]')
end
Qij=zeros(n,n);
Qij(:,1)=fx;
numerador=0;
denominador=0;
fprintf('\n');
fprintf('-----------------------------------------------------------------------\n');
fprintf('-------------CALCULANDO------------------------------------------------\n');
i=0;
fprintf('Qij=[(x-xi-j)Qij-1-(x-xi)Qi-1j-1]/(xi-xi-j)\n');
for i=1:n
fprintf('Q%1.0f0=P%1.0f=F(%1.2f)=%2.15f\n',i-1,i-1,xi(i),Qij(i,1));
end
for i=2:n
for j=2:n
if i>=j
if i==j
numerador=(vx-xi(1))*Qij(i,j-1)-(vx-xi(i))*Qij(i-1,j-1);
denominador=xi(i)-xi(1);
fprintf('Q%1.0f%1.0f=((x-x0)*Q%1.0f%1.0f-(x-x%1.0f)*Q%1.0f%1.0f)/(x%1.0f-x0)=',i-1,j-1,i-1,j-2,i-1,i-2,j-2,i-1);
else
numerador=(vx-xi(i-j+1))*Qij(i,j-1)-(vx-xi(i))*Qij(i-1,j-1);
denominador=xi(i)-xi(i-j+1);
fprintf('Q%1.0f%1.0f=((x-x%1.0f)*Q%1.0f%1.0f-(x-x%1.0f)*Q%1.0f%1.0f)/(x%1.0f-x%1.0f)=',i-1,j-1,i-j,i-1,j-2,i-1,i-2,j-2,i-1,i-j);
end
Qij(i,j)=numerador/denominador;
fprintf('%2.15f/%2.15f=%2.15f\n',numerador,denominador,Qij(i,j));
end
end
end
fprintf('\n-----------------------------------------------------------------------\n');
fprintf('----------------IMPRIMIENDO----------------------------------------------\n');
fprintf('\nEl valor aproximado es Q%1.0f%1.0f=%2.15f\n',i-1,j-1,Qij(i,j));
if p_g==1
fprintf('\nEl valor exacto es %3.15f\n',subs(f,vx));
error=abs(Qij(i,j)-subs(f,vx));
fprintf('\nEl Error es Error=%e\n',error);
end
fprintf('-----------------------------------------------------------------------\n');
Qij;
fprintf('-----------------------------------------------------------------------\n');
***********************************************************************************************
ResponderEliminar********************** NEVILLE CON FUNCION******************************************
***********************************************************************************************
function neville2()
disp('Método de interpolación de Neville');
y=input('Ingrese el número a evaluar: ');
syms x
fx=input('Ingrese la función: ');
n=input('Ingrese el número de datos: ');
f=zeros(1,n);
x=zeros(1,n);
Q=zeros(n-1,n-1);
for i=1:n
fprintf('Ingrese el valor de x%d: ',i-1);
x(i)=input('');
f(i)=subs(fx,x(i));
end
for l=1:n-1
for m=l:n-1
if l==1
Q(m,l)=((y-x(m))*f(m+1)-(y-x(m+1))*f(m))/(x(m+1)-x(m));
fprintf('\nQ[%d,%d]= (X-X(%d))Q[%d,%d]-(X-X(%d))Q[%d,%d])',m,l,m-1,m,l-1,m,m-1,l-1);
fprintf('\n-------------------------------------------- = %.9f',Q(m,l));
fprintf('\n\t\t\tX(%d)-X(%d)\n',m,m-1);
else
Q(m,l)=((y-x(m-l+1))*Q(m,l-1)-(y-x(m+1))*Q(m-1,l-1))/(x(m+1)-x(m-l+1));
fprintf('\nQ[%d,%d]= (X-X(%d))Q[%d,%d]-(X-X(%d))Q[%d,%d])',m,l,m-l,m,l-1,m-1,m-1,l-1);
fprintf('\n-------------------------------------------- = %.9f',Q(m,l));
fprintf('\n\t\t\tX(%d)-X(%d)\n',m,m-l);
end
end
end
fprintf('\n\nEl valor aproximado de t es: %.9f',Q(n-1,n-1));
fprintf('\n\nEl valor aproximado de t es: %.9e',Q(n-1,n-1));
exacto=subs(fx,y);
fprintf('\nEl valor exacto es: %.9f ',exacto);
fprintf('\nEl error es: %.9f \n',exacto-Q(n-1,n-1));
*******************************************************************************************
ResponderEliminar********************* NEVILLE SIN FUNCION ***************************************
******************************************************************************************
clear all
clc
disp('Metodo de Neville Sin Funcion')
disp('Recuerde que no hay funcion, debe de ingresar los datos con la funcion ya evaluada')
po=input('Ingrese el número a evaluar: ');
n=input('Ingrese el número de datos: ');
%creo las variables en que se almacenara los datos
x=zeros(1,n);
f=zeros(1,n);
Q=zeros(n-1,n-1);
%Pido los datos de entrada
for i=1:n
fprintf('Ingrese el valor de x%d: ',i-1);
x(i)=input('');
fprintf('Ingrese el valor de f(x%d): ',i-1);
f(i)=input('');
end
%comienzo a evaluar los datos
%se crean los Q(x,y)
for l=1:n-1
for m=l:n-1
%El if esta xq si l>1 ya no se usan los valores de F(xi) sino que se usan los valores previamente obtenidos de Q
if l==1
%Calculo el valor de Q(x,y) y la Ec. la coloco en pantalla
Q(m,l)=((po-x(m))*f(m+1)-(po-x(m+1))*f(m))/(x(m+1)-x(m));
fprintf('\nQ[%d,%d]= (X-X(%d))Q[%d,%d]-(X-X(%d))Q[%d,%d])',m,l,m-1,m,l-1,m,m-1,l-1);
fprintf('\n-------------------------------------------- = %.9f',Q(m,l));
fprintf('\n\t\t\tX(%d)-X(%d)\n',m,m-1);
else
%Calculo el valor de Q(x,y) y la Ec. la coloco en pantalla
Q(m,l)=((po-x(m-l+1))*Q(m,l-1)-(po-x(m+1))*Q(m-1,l-1))/(x(m+1)-x(m-l+1));
fprintf('\nQ[%d,%d]= (X-X(%d))Q[%d,%d]-(X-X(%d))Q[%d,%d])',m,l,m-l,m,l-1,m-1,m-1,l-1);
fprintf('\n-------------------------------------------- = %.9f',Q(m,l));
fprintf('\n\t\t\tX(%d)-X(%d)\n',m,m-l);
end
end
end
fprintf('\n\nEl valor aproximado de x es: %.9f\n\n',Q(n-1,n-1));
fprintf('\n\nEl valor aproximado de x es: %.9e\n\n',Q(n-1,n-1));
*************************************************************************************************
ResponderEliminar******************************** NEVILLE version corta **********************************
*************************************************************************************************
°°°°°°°°°°°°°declarar X y Y antes de correr el programa, y luego colocar neville(x,y) y dejar que corra normalmente °°°°°°°°°°°°°°°°°°°°°°°°°°°°°°
function [D]=neville(X,Y)
n=length(X);
D=zeros(n,n);
X0=input('Ingrese el valor a evaluar: ');
D(:,1)=Y';
for j=2:n
for k=j:n
D(k,j)=(((X0-X(k-j+1))*D(k,j-1))-((X0-X(k))*D(k-1,j-1)))/(X(k)-X(k-j+1));
fprintf('Q(%2.0f%2.0f)=(x-X%2.0f)Q(%2.0f%2.0f)-(x-X%2.0f)Q(%2.0f%2.0f)/(X%2.0f-X%2.0f) = %9.8f\n',k-1,j-1,k-j,k-1,j-2,k-j+1,k-2,j-2,k-j+1,k-j,D(k,j));
end
end
fprintf('El valor aproximado es= %9.8f',D(n,n));
DIFERENCIAS DIVIDIDAS CON DATOS
ResponderEliminarsyms x;
xi=input('Ingrese los datos de entrada en forma de vector(X): ');
yi=input('Ingrese los datos evaluados en forma de vector(Y): ');
y=input('Ingrese el número a evaluar: ');
n = length(xi);
dif=zeros(n,n);
dif(:,1) = yi';
polinomio=0;
factor=1;
polinomio=polinomio+dif(1,1);
for l=2:n
for m=l:n
dif(m,l)=(dif(m,l-1)-dif(m-1,l-1))/(xi(m)-xi(m-l+1));
if m==l
for t=1:l-1
factor=factor*(x-xi(t));
end
polinomio=polinomio+(dif(m,l)*factor);
factor=1;
end
end
end
fprintf('\n\nP(x)=\n');
pretty(polinomio);
a=subs(polinomio,y);
fprintf('\n\nEl valor de P(%f) es: %.15f\n\n',y,a);
DIFERENCIAS DIVIDIDAS CON FUNCION
ResponderEliminarX=input('Introduzca los valores de X [xo,x1,x2,...,x3]: ');
syms x
f=input('Introduzca la funcion f(x): ');
pto=input('Introduzca el punto a aproximar: ');
Y=subs(f,X);
n=length(X);
Q=zeros(n,n);
Q(:,1)=Y';
c=2;
k=1;
for j=2:1:n
for i=c:1:n
Q(i,j)=(Q(i,j-1)-Q(i-1,j-1))/(X(i)-X(i-k));
end
k=k+1;
c=c+1;
end
fprintf('\nLa matriz Q es: \n')
disp(Q)
fprintf('\nEl polinomio P es: \n')
syms x
c=1;
prod=1;
P=Q(1,1);
for N=2:1:n
for i=1:1:c
prod=prod*(x-X(i));
end
c=c+1;
P=P+prod*Q(N,N);
prod=1;
end
pretty(P)
valor_aprox=subs(P,pto);
valor_exacto=subs(f,pto);
resta=abs(valor_exacto-valor_aprox);
fprintf('\nEl valor aproximado es: %9.15f',valor_aprox)
fprintf('\nEl valor exacto es: %9.15f',valor_exacto)
fprintf('\nEl error entre las cifras es: %e',resta)
fprintf('\n')
HERMITE CON DATOS DIFERENCIAS
ResponderEliminarsyms x;
disp('Ingrese los valores de X en forma de vector []');
xi=input('x0,x1,.....,xn:');
z=zeros(1,length(xi)*2);
fxi=input('Valores evaluados en la función:');
fpxi=input('Valores evaluados en la derivada de la función:');
vx=input('x=');
H=0;
Ffxi=zeros(length(xi)*2,length(xi)*2);
j=0;
for i=1:length(xi)
fprintf('x%1.0f=%2.2f\n',i-1,xi(i))
z(1,i+j)=xi(i);
z(1,i+j+1)=xi(i);
Ffxi(i+j,1)=fxi(i);
Ffxi(i+j+1,1)=fxi(i);
Ffxi(i+j,2)=fpxi(i);
Ffxi(i+j+1,2)=fpxi(i);
j=j+1;
end
for i=1:length(xi)*2
fprintf('z%1.0f=%2.2f F(z%1.0f)=%2.9f F`(z%1.0f)=%2.9f\n',i-1,z(1,i),i-1,Ffxi(i,1),i-1,Ffxi(i,2));
end
Ffxi(length(xi)*2,2)=0;
k=length(xi)*2-1;
n=0;
factor=1;
for j=2:length(xi)*2
n=n+1;
for i=1:k
if (z(1,i+n)-z(1,i))~=0
Ffxi(i,j)=(Ffxi(i+1,j-1)-Ffxi(i,j-1))/(z(1,i+n)-z(1,i));
end
end
k=k-1;
end
fprintf('\nDada la matriz triangular superior izquierda fxi=\n');
k=length(xi)*2;
for i=1:length(xi)*2
fprintf('z%1.0f=%2.2f--> ',i-1,z(1,i));
for j=1:k
if Ffxi(i,j)<1e-3
fprintf('%e ',Ffxi(i,j));
else
fprintf('%2.9f ',Ffxi(i,j));
end
end
k=k-1;
fprintf('\n');
end
fprintf('\nSe extrae :\n');
for i=1:length(xi)*2
if Ffxi(1,i)<1e-3
fprintf('a%1.0f=%e\n',i-1,Ffxi(1,i));
else
fprintf('a%1.0f=%2.9f\n',i-1,Ffxi(1,i));
end
end
factor=1;
fprintf('\nH%1.0f(x)=a0+',length(xi)*2-1);
H=H+Ffxi(1,1);
for i=2:length(xi)*2
fprintf('a%1.0f',i-1);
for j=1:i-1
fprintf('(x-z%1.0f)',j-1);
factor=factor*(vx-z(1,j));
end
H=H+Ffxi(1,i)*factor;
factor=1;
if i==length(xi)*2
fprintf('=');
else
fprintf('+');
end
end
fprintf('\n%2.9f\n',H);
HERMITE CON FUNCION DIFERENCIAS
ResponderEliminardisp('Método de interpolación de Hermite usando diferencias divididas');
y=input('Ingrese el número a evaluar: ');
syms x
f=input('Ingrese la función: ');
n=input('Ingrese el número de nodos: ');
n=2*n;
xi=zeros(1,n);
fxd=zeros(1,n);
dif=zeros(n,n);
px=0;
Lnk=1;
fd=diff(f);
for k=1:2:n
fprintf('Ingrese el valor de x%d: ',k-1);
xi(k)=input('');
xi(k+1)=xi(k);
dif(k,1)=subs(f,xi(k));
dif(k+1,1)=dif(k,1);
fxd(k)=subs(fd,xi(k));
fxd(k+1)=fxd(k);
if k==1
px=px+dif(k,1);
end
end
syms x
for l=2:n
for m=l:n
if xi(m)==xi(m-l+1)
dif(m,l)=fxd(m);
else
dif(m,l)=(dif(m,l-1)-dif(m-1,l-1))/(xi(m)-xi(m-l+1));
end
if m==l
for t=1:l-1
Lnk=Lnk*(x-xi(t));
end
px=px+(dif(m,l)*Lnk);
Lnk=1;
end
end
end
p=1;
for l=1:n
fprintf('\n%.15f\t\t%.15f\t\t',xi(l),dif(l,1));
for m=2:p
fprintf('%.15f\t\t',dif(l,m));
end
p=p+1;
end
fprintf('\n\nP(x)=\n');
pretty(px);
a=subs(px,y);
fprintf('\n\nEl valor de P(%f) es: %.15f\n\n',y,a);
w=subs(f,y);
fprintf('El valor exacto de f(x) es: %.15f\n',w);
error=abs(w-a);
fprintf('El error de aproximación es: %.15E\n\n',error);
LAGRANGE CON DATOS
ResponderEliminarsyms x;
puntos=input('Ingrese puntos en forma de arreglo: ');
valores=input('Ingrese valores en forma de arreglo: ');
n = length(puntos);
po=input('Ingrese el número a evaluar: ');
EcLagrange=0;
La=1;
Lb=1;
L=zeros(1,n);
for i=1:n
for j=1:n
if j~=i
La=La*(x-puntos(j));
Lb=Lb*(puntos(i)-puntos(j));
end
end
fprintf('L%d(x)=\n',i-1);
pretty(La/Lb);
fprintf('\n--------------------------------------------------------------------------------\n\n');
funcion=La/Lb;
EcLagrange=EcLagrange+funcion*valores(i);
L(i)=subs(po,funcion);
La=1;
Lb=1;
end
fprintf('Polinomio de Lagrange:\n');
pretty(EcLagrange);
resultado=subs(EcLagrange,po);
fprintf('\n\nEl valor del polinomio evaluado en %f es de: %.8f\n',po,resultado);
LAGRANGE CON FUNCION
ResponderEliminardisp('Método de interpolación usando polinomios de Lagrange - Con funcion');
n=input('Ingrese el número de nodos: ');
xk=zeros(1,n);
for j=1:n
fprintf('Introduce el X%g: ', j-1)
xk(j)=input('');
end
syms x
f=input('Ingrese la función: ');
v=input('Ingrese el valor a evaluar: ');
fxk=zeros(1,n);
Lnk=1;
Px=0;
syms x
for l=1:n
fxk(l)=subs(f,xk(l));
for m=1:n
if m~=l
Lnk=Lnk*(x-xk(m))/(xk(l)-xk(m));
end
end
fprintf('f(x%d)=%.15f\n\nL%d(x)=\n',l-1,fxk(l),l-1);
pretty(Lnk);
fprintf('\n--------------------------------------------------------------------------------\n\n');
Px=Px+fxk(l)*Lnk;
Lnk=1;
end
fprintf('Polinomio de Lagrange:\n');
pretty(Px);
Pv=subs(Px,v);
fv=subs(f,v);
error=abs(Pv-fv);
fprintf('\n\nValor del polinomio evaluado en %f: %.15f\n',v,Pv);
fprintf('Valor de la función evaluada en %f: %.15f\n',v,fv);
fprintf('Error: %.15E\n\n',error);
NEVILLE CON FUNCION
ResponderEliminardisp('Método de interpolación de Neville');
y=input('Ingrese el número a evaluar: ');
syms x
fx=input('Ingrese la función: ');
n=input('Ingrese el número de datos: ');
f=zeros(1,n);
x=input('Ingrese los datos [...]: ');
Q=zeros(n-1,n-1);
for i=1:n
f(i)=subs(fx,x(i));
end
for l=1:n-1
for m=l:n-1
if l==1
Q(m,l)=((y-x(m))*f(m+1)-(y-x(m+1))*f(m))/(x(m+1)-x(m));
fprintf('\nQ[%d,%d]= (X-X(%d))Q[%d,%d]-(X-X(%d))Q[%d,%d])',m,l,m-1,m,l-1,m,m-1,l-1);
fprintf('\n-------------------------------------------- = %.15f',Q(m,l));
fprintf('\n\t\t\tX(%d)-X(%d)\n',m,m-1);
else
Q(m,l)=((y-x(m-l+1))*Q(m,l-1)-(y-x(m+1))*Q(m-1,l-1))/(x(m+1)-x(m-l+1));
fprintf('\nQ[%d,%d]= (X-X(%d))Q[%d,%d]-(X-X(%d))Q[%d,%d])',m,l,m-l,m,l-1,m-1,m-1,l-1);
fprintf('\n-------------------------------------------- = %.15f',Q(m,l));
fprintf('\n\t\t\tX(%d)-X(%d)\n',m,m-l);
end
end
end
fprintf('\n\nEl valor aproximado de x es: %.15f',Q(n-1,n-1));
fprintf('\n\nEl valor aproximado de x es: %.9e',Q(n-1,n-1));
exacto=subs(fx,y);
fprintf('\nEl valor exacto es: %.15f ',exacto);
fprintf('\nEl error es: %.15f \n',exacto-Q(n-1,n-1));
NEVILLE CON DATOS
ResponderEliminarx=input('Ingrese los puntos(X):');
f=input('Ingrese los puntos evaluados(Y):');
po=input('Ingrese el número a evaluar: ');
n = length(x);
Q=zeros(n-1,n-1);
for l=1:n-1
for m=l:n-1
if l==1
Q(m,l)=((po-x(m))*f(m+1)-(po-x(m+1))*f(m))/(x(m+1)-x(m));
fprintf('\nQ[%d,%d]= (X-X(%d))Q[%d,%d]-(X-X(%d))Q[%d,%d])',m,l,m-1,m,l-1,m,m-1,l-1);
fprintf('\n-------------------------------------------- = %.15f',Q(m,l));
fprintf('\n\t\t\tX(%d)-X(%d)\n',m,m-1);
else
Q(m,l)=((po-x(m-l+1))*Q(m,l-1)-(po-x(m+1))*Q(m-1,l-1))/(x(m+1)-x(m-l+1));
fprintf('\nQ[%d,%d]= (X-X(%d))Q[%d,%d]-(X-X(%d))Q[%d,%d])',m,l,m-l,m,l-1,m-1,m-1,l-1);
fprintf('\n-------------------------------------------- = %.15f',Q(m,l));
fprintf('\n\t\t\tX(%d)-X(%d)\n',m,m-l);
end
end
end
fprintf('\n\nEl valor aproximado de x es: %.15f\n\n',Q(n-1,n-1));
NEVILLE CON DATOS Y FUNCION
ResponderEliminarsyms x
opcion=input('¿Conoce la función f(x)? (SI=1, NO=0): ');
if opcion==1
f=input('Digite la función de trabajo: ');
p=input('Digite los valores iniciales de x [x0 x1 x2 ... xn]: ');
y=subs(f,p);
else
p=input('Digite los valores iniciales de x [x0 x1 x2 ... xn]: ');
y=input('Digite los valores de f(x) [y0 y1 y2 ... yn]: ');
end
p0=input('Introduzca el valor de x a aproximar: ');
long=length(p);
Q=zeros(long,long);
Q(:,1)=y'; %Diagonal principal
for j=2:long
for i=j:long
Q(i,j)=((p0-p(i+1-j))*Q(i,j-1)-(p0-p(i))*Q(i-1,j-1))/(p(i)-p(i+1-j));
fprintf('\n\nQ(%3.0f,%3.0f)=(X-X(%3.0f))Q(%3.0f,%3.0f)-(X-X(%3.0f))Q(%3.0f,%3.0f)\n',i-1,j-1,i-j,i-1,j-2,i-1,i-2,j-2)
fprintf('\t\t\t____________________________________________= %10.15f',Q(i,j))
fprintf('\n\t\t\t\t (X(%3.0f)-X(%3.0f))',i-1,i-j)
end
end
fprintf('\n\nEl valor aproximado es: %10.15f\n',Q(long,long))
if opcion==1
R=subs(f,p0);
error=abs(Q(long,long)-R);
fprintf('\nEl valor real de la función evaluada es: %10.15f',R)
fprintf('\nEl error de aproximación es: %e\n',error)
end
DIFERENCIAS DIVIDIDAS
ResponderEliminarsyms x;
X = input('Ingrese los valores de X de la forma [x1, x2, x3... ]: ');
x0 = input('Ingrese el valor a aproximar: ');
n = length(X); %Longitud n
D = zeros(n,n); %Inicializando matriz
opc = input('Posee una funcion de trabajo?\n1.Si\n2.No\n>> ');
if(opc == 1) %Si hay funcion
fx = input('Ingrese la funcion: ');
Y = subs(fx, X); %Vector con valores evaluados
else
Y = input('Ingrese los valores de Fx de la forma [fx1, fx2,...n]: ');
end
D(:,1) = Y'; %Transpuesta con los valores Fx
for j = 2 : n
for k = j : n
D(k,j) = ( D(k, j-1) - D(k-1, j-1) ) / ( X(k) - X(k - j + 1) );
end %Fin segundo for
end %Fin primer for
D %Imprimiendo D
fprintf('P%2d(x) = ', n-1);
str_aux = '';
producto = 1;
respuesta = 0;
for j = 1 : n
if(j > 1)
str_aux = strcat(str_aux,'(X - ', num2str(X(j-1)), ')*' );
producto = producto * (x0 - X(j-1));
end
fprintf('D(%2d, %2d) * %s + \n', j, j, str_aux);
respuesta = D(j, j) * producto + respuesta;
%end
end
fprintf('El valor aproximado es: %10.15f\n', respuesta);
if(opc == 1)
exacto = subs(fx, x0)
error = abs(exacto - respuesta);
fprintf('Error: %e \n', error);
end