Implementación en lenguaje C del algoritmo de Newton y el algoritmo de interpolación lagrangiana
# include & ltstdio.h & gt
# include & ltstdlib.h & gt
# include & ltiostream.h & gt
datos de estructura typedef
{
Flotante x;
Flotante y
}Datos; Variables Estructura de x y valor de función y
Datos d[20]; //Hasta 20 conjuntos de datos
Float f(int s, int t)//Método de interpolación de Newton , usado Volver al negocio.
{
Si (t==s+1)
retorna (d[t].y-d[s].y)/(d[t ].x-d[s]. ].x-d[s].x);
}
Flotador Newton(float int n;
mientras(1)
{
cout & lt& lt"Ingrese n valores (es decir, n tiempos de interpolación):" // Obtenga el número de interpolaciones
CIN>>n;
If (n<=count-1)//El número de interpolaciones no debe ser mayor que contar-1 veces.
Romper;
Otro
Sistema("cls");
}
//Inicializar t ,y,yt.
flotador t = 1.0;
Punto flotante y=d[0]. y;
flotar yt = 0.0
//Calcular el valor de y
for(int j = 1; j & lt= n; j++)
{
t=(x-d[j-1].x)*t;
yt=f(0,j)*t;
//cout <<f(0,j)<<endl
y = y+yt;
}
Devuelve y ;
}
Lagrangiano de punto flotante (punto flotante x, recuento de enteros)
{
flotante y = 0,0
para (int k = 0; k & lt count; K++) // El valor predeterminado aquí es la interpolación de conteo-1.
{
Punto flotante p = 1.0; //Inicializar p
for(int j = 0; j & lt count; j++)
{//Calcular el valor de p.
if(k==j)continue; //Determina si es el mismo número.
p=p*(x-d[j]). x)/(d[k].x-d[j].x);
}
y=y+p*d[k]. y; //Suma
}
Devuelve y; //Devuelve el valor de y.
}
void main()
{
Punto flotante x, y
int count;
while(1)
{
cout & lt& ltIngrese el número de x [i] e y [i], no más de 20 grupos: ";//Pide al usuario que introduzca el número de grupos de datos.
CIN>>count;
if(count<=20)
Break; / /Compruebe si la entrada es legal.
System("cls");
}
//Obtener cada conjunto de datos
for(int I = 0; i & ltCount; i++)
{
cout & lt& lt"Ingrese el primero"
CIN & gt;& gtd[i]. x;
cout & lt& lt"Ingrese el primero"
CIN & gt;& gtd[i]. y;
System("cls");
}
cout & lt& ltIngrese el valor de x: ";//Obtenga el valor de la variable x
CIN>& gtx;
mientras(1)
{
int elección = 3;
cout & lt& lt"Seleccione el método de interpolación a utilizar:"
cout & lt& lt"(0):Salir"
cout & lt& lt"(1): Lagrange " & lt& ltendl
cout & lt& lt"(2):Newton"& lt& ltendl
cout & lt& lt"Ingrese su selección:";
CIN>& gtSelect; //Obtiene la elección del usuario
if(select==2)
{
cout & lt& lt "Seleccionó el Newton. método de cálculo de interpolación, y el resultado es: ";
y = Newton(x, count); //Llame al controlador correspondiente.
}
if (choice==1)
{
cout & lt& lt"Elegiste el método de cálculo de interpolación lagrangiana y el resultado es:"
y = Lagrange(x, count); break; // Llama al controlador apropiado
if(select ==. 0)
Break;
system("cls ");
cout<<"¡Error de entrada! ! ! !"& lt& ltendl
}
cout & lt& ltx & lt& lt","& lt& lty & lt& ltendl//Generar el resultado final
}