二次插值法C语言程序
数值分析插值算法源程序
#include<stdio.h>#include<math.h>float f(float x) //计算ex的值{return (exp(x));}float g(float x) //计算根号x的值{return (pow(x,0.5));}void linerity () //线性插值{float px,x;float x0,x1;printf("请输入x0，x1的值\n");scanf("%f,%f",&x0,&x1);printf("请输入x的值: ");scanf("%f",&x);px=(x-x1)/(x0-x1)*f(x0)+(x-x0)/(x1-x0)*f(x1);printf("f(%f)=%f \n",x,px);}void second () //二次插值{float x0,x1,x2,x,px;x0=0;x1=0.5;x2=2;printf("请输入x的值:");scanf("%f",&x);px=((x-x1)*(x-x2))/((x0-x1)*(x0-x2))*f(x0)+((x-x0)*(x-x2))/((x1-x0)*(x1-x2))*f(x1)+((x-x0)* (x-x1))/((x2-x0)*(x2-x1))*f(x2);printf("f(%f)=%f\n",x,px);}void Hermite () //Hermite插值{int i,k,n=2;int flag1=0;printf("Hermite插值多项式H5(x)=");for(i=0;i<=n;i++){int flag=0;flag1++;if(flag1==1){printf("y%d[1-2(x-x%d)*(",i,i);}else{printf("+y%d[1-2(x-x%d)*(",i,i);}for(k=0;k<=n;k++){if(k!=i){flag++;if(flag==1){printf("(1/x%d-x%d)",i,k);}else{printf("+(1/x%d-x%d)",i,k);}}}printf(")]*（");for(k=0;k<=n;k++){if(i!=k){printf("[(x-x%d)/(x%d-x%d)]2",i,k,i);}}printf("）");}printf("\n");}void sectionl () //分段线性插值{float x[5]={2.0,2.1,2.2,2.3,2.4};float y;printf("请输入y：");scanf("%f",&y);if(y>=2.0&&y<2.1){float px;px=((y-x[1])/(x[0]-x[1]))*g (x[0])+((y-x[0])/(x[1]-x[0]))*g (x[1]);printf("f(%f)=%f\n",y,px);}else if(y>=2.1&&y<2.2){float px;px=((y-x[2])/(x[1]-x[2]))*g (x[1])+((y-x[1])/(x[2]-x[1]))*g (x[2]);printf("f(%f)=%f\n",y,px);}else if(y>=2.2&&y<2.3){float px;px=((y-x[3])/(x[2]-x[3]))*g (x[2])+((y-x[2])/(x[3]-x[2]))*g (x[3]);printf("f(%f)=%f\n",y,px);}else if(y>=2.3&&y<2.4){float px;px=((y-x[4])/(x[3]-x[4]))*g (x[3])+((y-x[3])/(x[4]-x[3]))*g (x[4]);printf("f(%f)=%f\n",y,px);}else if(y>2.4) printf("**********ERROR!******************\n"); }void sectionp (){int i;float a[5]={2.0,2.1,2.2,2.3,2.4};float x,y;printf("input the data: x?\n");scanf("%f",&x);if(x<a[1]){i=1;goto loop;}if(x>a[4]){i=4;goto loop;}i=1;loop1:i++;if(x>a[i])goto loop1;if(fabs(x-a[i-1])<=fabs(x-a[i]))i=i-1;loop:y=g(a[i-1])*(x-a[i])*(x-a[i+1])/((a[i-1]-a[i])*(a[i-1]-a[i+1]));y=y+g(a[i])*(x-a[i-1])*(x-a[i+1])/((a[i]-a[i-1])*(a[i]-a[i+1]));y=y+g(a[i+1])*(x-a[i-1])*(x-a[i])/((a[i+1]-a[i-1])*(a[i+1]-a[i]));printf("f(%f)=%f\n",x,y);}int main(){char flag1='y';while(flag1=='y'){int flag=0;printf("*******[1]:线性插值***************\n");printf("*******[2]:二次插值***************\n");printf("*******[3]:Hermite插值************\n");printf("*******[4]:分段线性插值***********\n");printf("*******[5]:分段抛物线插值*********\n");printf("请输入：");scanf("%d",&flag);switch(flag){case 1:linerity ();break;case 2:second ();break;case 3:Hermite ();break;case 4:sectionl ();break;case 5:sectionp ();break;default:printf("error!!\n");}printf("是否继续？y/n \n");getchar();scanf("%c",&flag1);}return 0;}。
二次插值法的基本原理
二次插值法的基本原理二次插值法是一种用于近似估计函数曲线的方法。
它的基本原理是通过已知数据点构造一个二次函数，然后利用该函数来预测未知数据点的值。
这种方法常用于数学建模、数据分析和图像处理等领域。
二次插值法的基本步骤包括：确定已知数据点、构造二次函数模型、求解二次函数参数、进行插值计算。
首先，我们需要确定已知数据点的横坐标和纵坐标值。
这些数据点应该尽可能地靠近我们要预测的未知数据点，以提高插值的准确性。
接下来，我们通过已知数据点构造一个二次函数模型。
二次函数的一般形式为f(x) = ax^2 + bx + c，其中a、b、c为待定系数。
我们可以通过已知数据点的坐标值，列出一系列的二次方程，然后求解这些方程组，得到二次函数的参数。
求解二次函数参数的方法有多种，常见的有拉格朗日插值和牛顿插值。
在拉格朗日插值中，通过已知数据点构造一个基于拉格朗日插值多项式的二次函数模型。
在牛顿插值中，通过已知数据点构造一个基于差商的二次函数模型。
这些方法都可以得到一个满足已知数据点的二次函数模型。
我们利用求解得到的二次函数模型来进行插值计算。
对于给定的未知数据点，我们将其横坐标代入二次函数模型中，即可得到对应的纵坐标值。
这个纵坐标值就是我们通过二次插值法预测出来的未知数据点的值。
二次插值法的优点是可以通过已知数据点构造一个光滑的曲线，从而更准确地预测未知数据点的值。
它适用于数据点较少、曲线变化较平缓的情况。
但是，如果数据点过于密集或者曲线变化较大，则二次插值法可能会产生较大的误差。
在实际应用中，二次插值法常常与其他插值方法或拟合方法结合使用，以提高估计的准确性。
例如，我们可以使用线性插值法来近似估计曲线的斜率，然后再利用二次插值法来计算未知数据点的值。
二次插值法是一种常用的近似估计函数曲线的方法。
通过已知数据点构造一个二次函数模型，然后利用该模型来预测未知数据点的值。
它可以在一定程度上提高估计的准确性，但在使用时需要考虑数据点的分布和曲线的变化情况。
二次样条插值及其C语言的实现
for(i=1;i<11;i++)
{
u[i]=(x[i]-x[i-1])/(x[i+1]-x[i-1]); //μ1~μ10的求解公式
v[i]=1-u[i]; //λ1~λ10的求解公式
g[i]=(6/(x[i+1]-x[i-1]))*((y[i+1]-y[i])/(x[i+1]-x[i])-(y[i]-y[i-1])/(x[i]-x[i-1])); //g1~g10的求解公式
}
for(i=0;i<11;i++)
{
printf("[ %.2f, %.2f ] :\n",x[i],x[i+1]);
printf("S= %fx^3+%fx^2+%fx+%f\n",X3[i+1],X2[i+1],X1[i+1],X0[i+1]);
printf("\n");
}
}
、最小二乘拟合函数：
int i,j=0;
int AllD=1; //三角对阵的行列式
double Mv=1,Mu=1; //Mv表示λ1*λ2*…*λ10，Mu表示μ1*μ2*…*μ10
double M[12],X3[11],X2[11],X1[11],X0[11]; //M[12]用于存放M0~M11，X3[11]用于存放x^3的系数，X2[11]用于存放x^2的系数,
}
g[0]=(6/(x[1]-x[0]))*((y[1]-y[0])/(x[1]-x[0])-0.75); //g0的求解公式
拉格朗日插值法C语言的实现(实验报告)
3.程序流程：
（1）输入已知点的个数； （2）分别输入已知点的 X 坐标； （3）分别输入已知点的 Y 坐标； （4）通过调用函数 lagrange 函数，来求某点所对应的函数值。
拉格朗日插值多项式如下：
L n ( x j ) yk lk ( x j ) y j j 0,1, ……n
1、进一步熟悉拉格朗日插值法。 2、掌握编程语言字符处理程序的设计和调试技术。
【实验内容】 （题目）作出插值点（-2.00，0.00） ， （2.00，5.00） ， （5.00，6.00）的二次 Lagrange 插值多项式 L2 （x） ，并计算 L2 (-1.2), L2 (1.2)。 解题思路：
k 0 n
其中 lk ( x )
( x x0 )……(x-x k-1 )(x-x k+1 )……(x-xn ) ( xk x0 )……(xk -xk-1 )(xk -xk+1 )……(xk -xn )
k 0,1, …… ,n
程序流程图：
开始
↓
输入已知点个数 n
↓
输入已知点的 X 坐标以及输 入已知点的 Y 坐标
第 9 页 共 9 页
第 5 页 共 9 页
韩山师范学院
C 语言程序设计
printf("\n"); for(i=0;i<=n-1;i++) { printf("y[%d]:",i);scanf("%f",&y[i]); } printf("\n"); printf("Input xx:"); scanf("%f",&xx); yy=lagrange(x,y,xx,n); printf("x=%f,y=%f\n",xx,yy); getch(); }
二次插值算法
二次插值法亦是用于一元函数在确定的初始区间搜索极小点的一种方法。
它属于曲线拟合方法的畴。
一、基本原理在求解一元函数的极小点时，常常利用一个低次插值多项式来逼近原目标函数，然后求该多项式的极小点(低次多项式的极小点比较容易计算)，并以此作为目标函数的近似极小点。
如果其近似的程度尚未达到所要求的精度时，可以反复使用此法，逐次拟合，直到满足给定的精度时为止。
常用的插值多项式为二次或三次多项式，分别称为二次插值法和三次插值法。
这里我们主要介绍二次插值法的计算公式。
假定目标函数在初始搜索区间中有三点、和，其函数值分别为、和(图1}，且满足，，即满足函数值为两头大中间小的性质。
利用这三点及相应的函数值作一条二次曲线，其函数为一个二次多项式（1）式中、、为待定系数。
图1根据插值条件，插值函数与原函数在插值结点、、处函数值相等，得（2）为求插值多项式的极小点，可令其一阶导数为零，即（3）解式(3)即求得插值函数的极小点（4）式(4)中要确定的系数可在方程组(2)中利用相邻两个方程消去而得:（5）（6）将式(5)、(6)代入式(4)便得插值函数极小值点的计算公式：（7）把取作区间的另一个计算点，比较与两点函数值的大小，在保持两头大中间小的前提下缩短搜索区间，从而构成新的三点搜索区间，再继续按上述方法进行三点二次插值运算，直到满足规定的精度要求为止，把得到的最后的作为的近似极小值点。
上述求极值点的方法称为三点二次插值法。
为便于计算，可将式(7)改写为（8）式中：（9）（10）二、迭代过程及算法框图(1)确定初始插值结点通常取初始搜索区间的两端点及中点为，，。
计算函数值，，，构成三个初始插值结点、、。
(2)计算二次插值函数极小点按式(8)计算，并将记作点，计算。
若本步骤为对初始搜索区间的第一次插值或点仍为初始给定点时，则进行下一步(3);否则转步骤(4)(3)缩短搜索区间缩短搜索区间的原则是：比较函数值、，取其小者所对应的点作为新的点，并以此点左右两邻点分别取作新的和，构成缩短后的新搜索区间。
二次样条插值及其C语言的实现范文
if(s == NULL)
{
printf("内存分配失败\n");
exit (0);
}
t = (double *)calloc(n,sizeof(double));
if(t == NULL)
{
printf("内存分配失败\n");
exit (0);
}
b = (double *)calloc(n,sizeof(double));
if(b == NULL)
{
printf("内存分配失败\n");
exit (0);
}
z = 0;
for(i=1;i<=n;i++)
z=z+x[i-1]/n;
b[0]=1;
d1=n;
p=0;
c=0;
for(i=1;i<=n;i++)
if(j%4==0) printf("\n");
}
printf("\n");
j=0;
printf("g(0) to g(11):\n");
for(i=0;i<12;i++)
{
printf(" %f ",g[i]);
j++;
if(j%4==0) printf("\n");
}
for(i=1;i<=12;i++)
return(1);
}
4、上机调试说明：
、三次样条差值函数：
2次插值
，并求这个插值函数
该法是以目标函数的二次插值函数的极小点作为新的中间插入点，进行区 是以目标函数的二次插值函数的极小点作为新的中间插入点， 的一维搜索方法。 间缩小的一维搜索方法。 α 设一元函数 f (α ) ，在单峰区间 [ α 1 , α 3 ] 内取一点 2 且 α 1 < α 2 < α 3 这三点对应的函数值分别为
之值代入式 将B，C之值代入式(2-32)，可求得 ， 之值代入 ，
α2 2 2 B 1 (α 2 − α32 ) f1 + (α32 − α12 ) f 2 + (α12 − α 2 ) f3 α =− = 2C 2 (α 2 − α3 ) f1 + (α3 − α1 ) f 2 + (α1 − α 2 ) f3
∗
图2-25（a） （ ）
图2-25 （b） ）
图2-25（c） （ ）
图2-25（d） （ ）
判断迭代终止条件
α 在一般情况下，因α 2 是前一次插值函数的极小值点， * 是本次插值函数的极 在一般情况下， 是前一次插值函数的极小值点， p * * * α 小值点， 的距离足够小时， 小值点，若α p 和α 2 的距离足够小时，即满足 α p − α 2 ≤ ε ，或 α p 和 2 两者原函数 值已很接近， 则停止迭代，这时， 值已很接近，即满足 | f 4 − f 2 |≤ ε ，则停止迭代，这时，若 f 4 < f 2 ，输出极小 值点 4 = α ∗ ，极小值 = f (α ∗ ) ; α f4 ∗ 否则， 否则，即 f 4 ≥ f 2 时，输出极小值点α 2 = α ，极小值 f 2 = f (α ∗ ) 。如不 满足上述迭代终止条件，则返回步骤(3)，再次缩短搜索区间，直至最后满足终止 满足上述迭代终止条件，则返回步骤 ，再次缩短搜索区间， 条件。 条件。
二次插值法计算公式
二次插值法计算公式二次插值法，又称为拉格朗日插值法，是一种用于在给定的一组数据点（x，y）中估计中间数据点的方法。
它是基于插值多项式的概念，通过一系列已知数据点的多项式来逼近未知数据点。
在计算机科学和数学领域广泛使用。
二次插值的计算公式如下：假设已知数据点的集合为{(x0, y0)，(x1, y1)，...，(xn, yn)}，其中xi为已知的x坐标，yi为对应的y值。
现在需要根据这些已知数据点来估计一个给定的x值的y值。
首先，我们需要定义二次插值多项式：P(x) = y0 * L0(x) + y1 * L1(x) + ... + yn * Ln(x)其中，Li(x)为拉格朗日基函数，具体形式如下：Li(x) = (x - x0) * (x - x1) * ... * (x - xi-1) * (x - xi+1) * ... * (x - xn) / ((xi - x0) * (xi - x1) * ... * (xi - xi-1) * (xi - xi+1) * ... * (xi - xn))通过以上公式就可以计算出给定的x值的y值。
但是上述的计算公式并不是直接使用的，一般会做一部分优化，以减少计算量和提高计算精度。
以下是一种通常使用的优化方法：1.首先，将已知数据点按照x值的大小进行排序。
2.然后，计算每个点对应的Li(x)的值，并将其保存起来。
3. 对于给定的x值，找到它在已知数据点中的位置，即找到第i个点，使得xi <= x < xi+14.根据上述信息，可以计算出P(x)的值。
这种方法的计算复杂度为O(n)，其中n为已知数据点的数量。
由于只需要计算一次P(x)，后续的估计可以直接使用P(x)的计算结果，因此相对高效。
需要注意的是，当数据点相距较远或者分布不均匀时，二次插值法可能会出现较大的误差。
在这种情况下，可以考虑使用其他插值方法，如三次插值法或样条插值法，以提高估计的精度。
04.第四讲 二次插值法
，并将
x
* p
记作x4，计算
f4，若此时为第一次插值或者x2点仍为初始给定点时，显 然x2和x4不是前后两次插值函数的极小值，不能进行终止判 断，故转入步骤 4）
4）缩短搜索区间。原则是：比较f2、f4，取较小者为新的x2 点，并以此点左右邻点分别取作新的x1点和x3点，这样就 有新的搜索区间[x1, x2 ] 。
x1 a, x2 0.5(a b), x3 b 计算它们的函数值 f1 f (x1 ), f 2 f (x2 ), f3 f (x3 ) 并且满足 f1 f 2 f 3 （“大—小—大”）变化关系。
a)第一次迭代
b)第二次迭代
（虚线为拟合函数图像，实线为原目标函数图像）
将a1，a2带入上式得：
x*p
x4
1 [ (x22 2 (x2
x32 ) f1 (x32 x12 ) f2 (x12 x22 ) f3 ]
x3 )
f1
( x3
x1 )
f21
( x1
x2 )
f 13
为方便计算，可将上式改写成
x
* p
0.5( x1
x3
C1 ) C2
根据原区间里X2和X4的相对位置和f2和f4的大小，区间的 收缩有四种情况：
x2 x4
f2 f4
f2 f 4
x1
x2 x4
x3
x2 x4
f2 f4
f2
f4
x1
x2
x4 x3
x2 x4
f2 f4
f4
f2
x1
二次插值法课件
为保证二次插值 P(t ) 有极小点，要求 2 1 '1 (t2 t1 ) 或 '2 0 由条件易得
P(t ) A(t t1 )2 B(t t1 ) C
' C B 其中 1 1
A
2 1 1' (t2 t 1 )
(t2 t1 )
然后求 P(t ) 的极小点。 令 P' (t ) 0，可解得 2 2 2 2 1 (t2 t3 ) 2 (t3 t12 ) 3 (t12 t2 ) 2 (t2 t3 )1 (t3 t1 )2 (t1 t2 )3
点 即为 (t ) 的极小点的一次近似，然后算 出在点 处的函数值 ( ) 。现在我们已有四 个点(t1 , 1 ) ， (t3 , 3 ) 和 ( , ) ，从中找 (t2 , 2 ) ， 出相邻的且满足“两头高中间低”的三点，然后 又以这三点作二次抛物线，……，如此重复下去， 就得到 (t )的极小点的新估计值，直至满足一定 的精度要求（ t2 ）为止。这个方法称 为三点二次插值法。
即从“两头高中间低”的搜素区间开始，我们可以 通过 三点作一条二次插值多项 (t1 , 1 ) (t2， , 2 ) (t， 3 , 3 ) (t1 , t3 ) 式曲线（抛物线），并且认为这条抛物线在区间 上近似于曲线 (t )。于是可以用这条抛物线 P(t ) 的极小点 ，作为 (t ) 极小点的近似。
2
令
P' (t ) 0
，得
' 1 2
(t2 t1 ) t1 ' 2 1 1 (t 2 t1 ) 2
它可作为 (t ) 的极小点的估计值，其算法与前边 类似，此方法称为二点二次插值法。
简述二次插值法的迭代过程
简述二次插值法的迭代过程一、原理介绍二次插值法是一种基于二次函数的插值方法，它利用已知的两个点的函数值和导数值，通过构建一个二次插值多项式，来逼近函数的根。
该方法的基本思想是，通过构造一个二次函数，使得该函数与待求解的非线性方程在两个已知点处的函数值和导数值相等，然后利用二次插值多项式的根来逼近方程的根。
二、迭代步骤二次插值法的迭代步骤如下：1. 选择两个初始点a和b，使得f(a)和f(b)异号，即f(a) * f(b) < 0。
这样可以保证方程在[a, b]之间存在根。
2. 在[a, b]区间内，根据二次插值多项式的构造原理，可以得到一个二次函数p(x)，使得p(a) = f(a)，p(b) = f(b)，p'(a) = f'(a)，p'(b) = f'(b)。
其中，f(x)为待求解的非线性方程。
3. 求解二次函数p(x)的根x0，即p(x0) = 0。
可以通过求解二次方程的公式来得到根的近似值。
4. 判断x0是否在[a, b]区间内。
如果x0不在[a, b]区间内，则重新选择a和b，并返回第2步。
如果x0在[a, b]区间内，则进入下一步。
5. 判断f(x0)的值是否满足收敛条件，即|f(x0)| < ε，其中ε为预设的收敛精度。
如果满足收敛条件，则x0为方程的近似解，结束迭代。
如果不满足收敛条件，则将x0作为新的b值，并重新选择一个新的a值，并返回第2步。
三、迭代收敛性二次插值法的迭代过程中，根的选择和收敛性是关键。
在选择根的初始点a和b时，需要满足f(a) * f(b) < 0，这样可以保证方程在[a, b]之间存在根。
在选择新的a和b时，一般会选择离根较近的点，以加快迭代速度。
对于二次插值法的收敛性，一般情况下是收敛的。
但是，如果方程的根处于函数的驻点或拐点附近，可能会导致迭代过程发散。
因此，在实际应用中，需要对迭代过程进行控制，设置合适的迭代次数或收敛精度，以确保迭代过程的稳定性和收敛性。
二次差值法
----对应前面四种情况
stop
第三节 二次插值法
4 .二次插值法注意的几点：
（1）判别框c2=0? 若成立，说明３个插值点在一条 直线上． （２)判别框(x4-x1)(x3-x4)>0? 区间［x1,x3] ． （3) 开关k=0 状态 k=1 别 x2 ，说 x4
第三节 二次插值法
5.练习:
第三节 二次插值法
2.二次插值法区间缩短的4种情况
start Input: a,b,epson x1 x3 ， x2=0.5(x1+x3), fi=f(xi),(i=1,2,3) k=0
3. 程 序 流 程 图
c1←(f3-f1)/(x3-x1), c2←[(f2-f1)/(x2-x1)-c1]/(x2-x3) Y c2=0? N x4←0.5(x1+x3-c1/c2) N (x4-x1)(x3-x4)>0? Y f4←f(x4) Y k=0? N |x4-x2|≤ epson? N Output: x*=x2, f(x*)=f2 Y f4<f2? Output: x*=x4, f(x*)=f4 Y N Y N x4>x2? x3←x4 f3←f4 N f2>f4? x1←x2 f1←f2 Y x3←x2 f3←f2 Y f2>f4? x1←x4 f1←f4 N x2←x4,f2←f4,k←1
若近似程度不满足精度要求时可以反复使用此法从四个点中选取三个点使函数值呈现高低高变化的前提下逐渐的缩短搜索区间二次插值多项式的极小点就逼近原目标函数的极小点
机械优化设计.二次插值法基本思路：
二次插值法又称抛物线法，它的基本思路是： 在寻求函数f(α)极小点的搜索区间内，取三个 点的函数值来构造一个二次插值多项式p(α),用 它的极小点（第四个点）近似地作为原目标函数 的极小点。若近似程度不满足精度要求时，可以 反复使用此法，从四个点中选取三个点，使函数 值呈现“高-低-高”变化的前提下逐渐的缩短搜 索区间，二次插值多项式的极小点就逼近原目标 函数的极小点。
二次插值法计算公式
二次插值法计算公式假设给定的数据有三个点：(x1,y1)，(x2,y2)，(x3,y3)。
首先，我们需要找到一个二次函数的通用表达式：y = ax^2 + bx + c。
然后，我们可以利用这个表达式和三个点的坐标来求解a、b和c的值。
由于我们有三个点的坐标，我们可以得到三个方程：(1) y1 = ax1^2 + bx1 + c(2) y2 = ax2^2 + bx2 + c(3) y3 = ax3^2 + bx3 + c现在，我们需要解这个方程组来得到a、b和c的值。
首先，我们可以从(1)式中解出c的值：c = y1 - ax1^2 - bx1然后，将c的值代入(2)和(3)式中，可以得到两个只包含a和b的方程：(4) y2 = ax2^2 + bx2 + y1 - ax1^2 - bx1(5) y3 = ax3^2 + bx3 + y1 - ax1^2 - bx1现在，我们可以解这个有两个未知数的方程组(4)和(5)来得到a和b 的值。
一种解法是使用克拉默法则。
假设D是方程组的行列式，Da是把D 中的第一列替换为(1,y2,y3)得到的行列式，Db是替换第二列得到的行列式。
那么，a和b的值分别为Da/D和Db/D。
具体地，我们可以得到：D=(x1^2,x1,1)(x2^2,x2,1)(x3^2,x3,1)Da=(1,x1,1)(y2,x2,1)(y3,x3,1)Db=(x1^2,1,1)(x2^2,y2,1)(x3^2,y3,1)由此，我们可以计算出a和b的值。
最后，将a和b的值代入最开始的二次函数的通用表达式中，我们可以得到一个具体的二次函数。
使用这个二次函数，我们就可以预测其他点的坐标了。
二分法程序清单
1、二分法程序清单：#include<stdio.h>#include<math.h>#include<conio.h>double f(double x){double y = 0;y = sin(x) - x*x/2;return y;}void main(){double a,b,y1,y2,temp;int e1,e2=1,n,i=0;printf("请输入根的区间：");scanf("%lf",&a);scanf("%lf",&b);y1=f(a);y2=f(b);if((y1*y2)<0){printf("要求小数点后的位数：");scanf("%d",&e1);while(e1>0){e2=e2*10;e1--;}n=(int)(log((b-a)*e2)/log(2));printf("对方程sinx-x2/2=0开始进行二分：\n");while(n>0){printf("第%d次二分结果:",i);temp=f((a+b)/2);if((f(a)*temp)<0){b=(a+b)/2;printf("a=%f,b=%f\n",a,b);}if((f(b)*temp)<0){a=(a+b)/2;printf("a=%f,b=%f\n",a,b);}n--;}}printf("方程的解是：%6.5f\n",(a+b)/2);}2、迭代法的求根程序清单：#include<stdio.h>#include<math.h>#include<conio.h>double f(double x){double y = 0;y = x*x*x-x-1;return y;}double fdao(double x){double a=1.0/3;return pow(x+1,a);}void main(){double x1,x2,a,b,e2=1;int i = 0,e1;printf("请输入根的区间：");scanf("%lf",&a);scanf("%lf",&b);if((f(a)*f(b))<0){printf("要求小数点后的位数：");scanf("%d",&e1);while(e1>0){e2=e2/10;e1--;}e2=e2/2;printf("e2=%f",e2);x1=a;printf("第%d次迭代后结果是：%20.19f\n",i,x1);x2=f(x1);while(fabs(x2-x1)>e2){printf("第%d次迭代后结果是：%20.19f\n",i,x2);x1=x2;x2=fdao(x1);}printf("共进行%d次迭代过程\n",i);printf("结果是：%20.19f\n",x2);}elseprintf("无法进行迭代!");}二分法：迭代法1拉格朗日插值#include<iostream>#include <iomanip>#include<math.h>using namespace std;float jisuanmokuai(int,float,float[],float[]);void main(){float a,x[50],y[50],l;int m,n;cout<<"题目:按下列数据"<<endl;cout<<"x:-3.0 -1.0 1.0 2.0 3.0"<<endl;cout<<"y:1.0 1.5 2.0 2.0 1.5"<<endl;cout<<"作二次插值，求x=-2,x=0,x=2.75时的函数近似值."<<endl;cout<<"输入插值次数:"<<endl;cin>>n;cout<<"输入计算次数:"<<endl;cin>>m;for(int i=0;i<=m;i++){for (int j=0;j<=n;j++){int h99=i+1,b99=j+1;cout<<"输入第"<<h99<<"个数的第"<<b99<<"个节点及函数值:"<<endl;cin>>x[j]>>y[j];}cout<<"输入要计算的x的值:"<<endl;cin>>a;l=jisuanmokuai(n,a,x,y);printf("%f\n",l);}}float jisuanmokuai(int n,float a,float x[],float y[]){float l=0,w;int i,j;for (i=0;i<=n;i++){w=1;for(j=0;j<=n;j++){if(i!=j)w=w*((a-x[j])/(x[i]-x[j]));}l=l+w*y[i];}return l;}2牛顿插值#include<iostream.h>void main (){double a,b;cout<<"please input a=";cin>>a;b=1.044303+0.33825*(a-0.3)+0.3969*(a-0.3)*(a-0.42)-0.1368*(a-0.3) *(a-0.42)*(a-0.50)-0.0275*(a-0.3)*(a-0.42)*(a-0.50)*(a-0.58) -0.5219*(a-0.3)*(a-0.42)*(a-0.50)*(a-0.58)*(a-0.66);cout<<"b="<<b<<endl;}1、Newton-Cotes求积分程序：#include<stdio.h>#include<conio.h>double NewtonCotes(double b[],double h);void main(){double y[5],I,a,b;int i;printf("请输入积分区间：");scanf("%lf",&a);scanf("%lf",&b);printf("请输入对应的函数值：\n");for(i=0;i<5;i++){scanf("%lf",&y[i]);}I=NewtonCotes(y,b-a);printf("利用Newton-Cotes积分公式求得函数)在(1.8,2.6)区间的积分值为：%6.5f\n",I);}double NewtonCotes(double y[],double h){double C;C=((y[0]+y[4])*7+(y[1]+y[3])*32+y[2]*12)*h/90;return C;}2、Romberg积分的程序清单：#include<iostream>#include<cmath>using namespace std;#define f(x) pow(x, 1.0 / 2)double Romberg(double a, double b);void main(){double a = 0.5, b = 1,jieguo;double real = 2.0 / 3 * (1 - pow(1.0 / 2, 3.0 / 2));printf("该积分的准确值是: %.17f\n\n", real);jieguo = Romberg(a, b);printf("由Romberg 公式计算后的积分值是: %.17f\n",jieguo); }double Romberg(double a, double b){int m, n;double h, x;double s, q;double jd,jingdu;double *y = new double[10];double p ;h = b - a;y[0] = h*(f(a) + f(b))/2.0;m = 1;n = 1;printf("请输入精度:");scanf("%lf",&jingdu);jd = jingdu + 1.0;while ((jd >= jingdu) && (m < 10)){p = 0.0;for (int i=0; i<n; i++){x = a + (i + 0.5) * h;p = p + f(x);}p = (y[0] + h*p)/2.0;s = 1.0;for (int k=1; k<=m; k++){s = 4.0*s;q = (s*p - y[k-1])/(s - 1.0);y[k-1] = p;p = q;}p = fabs(q - y[m-1]);m = m + 1;y[m-1] = q;n = n + n; h = h / 2.0;}return q;}1、高斯列主元消去法#include<stdio.h>void main(){float a[4][4]={{10,7,8,7},{7,5,6,5},{8,6,10,9},{7,5,9,10}}, y[4],c[4][4],x[4],d[4],m,b;int i,n,j,f;printf("请输入右端顶:\n");for (i=0;i<=3;i++)scanf("%f",&y[i]);for (n=0;n<=2;n++){m=a[n][n];f=n;for(i=(n+1);i<=3;i++){if(m<a[i][n]){m=a[i][n];f=i;}}if(f!=n){for(j=0;j<=3;j++){c[n][j]=a[n][j];a[n][j]=a[f][j];a[f][j]=c[n][j];}d[n]=y[n];y[n]=y[f];y[f]=d[n];}for(i=(n+1);i<=3;i++){b=-a[i][j]/a[n][n];for(j=0;j<=3;j++)a[i][j]=a[n][j]*b+a[i][j];y[i]=y[n]*b+y[i];}}x[3]=y[3]/a[3][3];x[2]=(y[2]-a[2][3]*x[3])/a[2][2];x[1]=(y[1]-a[1][3]*x[3]-a[1][2]*x[2])/a[1][1];x[0]=(y[0]-a[0][3]*x[3]-a[0][2]*x[2]-a[0][1]*x[1])/a[0][0];printf("x1的值为%f\nx2的值为%f\nx3的值为%f\nx4%f\n",x[0],x[1],x[2],x[3]);}2、直接三角分解法#define N 5#include<stdio.h>void main(){int i,j,r,k;float a[N][N],l[N][N],u[N][N],b[N],x[N],y[N];float de=0;printf("please imput the%d*%d matrix A:\n",N-1,N-1);for(i=1;i<N;i++)for(j=1;j<N;j++)scanf("%f",&a[i][j]);printf("please imput the l*%d matrix b:\n",N-1);for(j=1;j<N;j++)scanf("%f",&b[j]);for(j=1;j<N;j++){u[1][j]=a[1][j];l[j][1]=a[j][1]/u[1][1];}for(r=2;r<N;r++){for(j=r;j<N;j++){for(k=1;k<r;k++){de+=l[r][k]*u[k][j];}u[r][j]=a[r][j]-de;de=0;}for(i=r+1;r<N;r++){for(k=1;k<r;k++){de+=l[i][k]*u[k][r];}l[i][r]=a[i][r]-de;l[i][r]=l[i][r]/u[r][r];de=0;}}for(i=1;i<N;i++){l[i][i]=1;}y[1]=b[1];for(k=2;k<N;k++){de=0;for(j=1;j<k;j++)de+=l[k][j]*y[j];y[k]=b[k]-de;}x[N-1]=y[N-1]/u[N-1][N-1];for(k=N-2;k>=1;k--){de=0;for(j=k+1;j<=N-1;j++)de+=u[k][j]*x[j];x[k]=(y[k]-de)/u[k][k];}printf("The matrix x is:\n");for(j=1;j<N;j++)printf("x(%d)=%f\n",j,x[j]);}高斯列主元直接三角分解：欧拉法程序#include <stdio.h>#include <math.h>void main(){float h,y[11],y1[11],y2[11],y3[11],s[11],s2[11];int i,n;printf("x的范围是(0,1),请输入步长h的值:");scanf("%f",&h);printf("\n");y[0]=1;s[0]=1;s2[0]=1;n=1/h;printf("步长h为%f时:\nx的值 y的近似值 y的精确度\n",h);for(i=0;i<=n;i++){y1[i]=y[i]+i*h;y3[i+1]=y[i]+h*y1[i];y2[i+1]=y3[i+1]+h*(i+1);y[i+1]=y[i]+h/2*(y1[i]+y2[i+1]);s[i+1]=y[i+1];s2[i+1]=-h*(i+1)-1+2*exp(h*(i+1));printf("%f,%f,%f\n",h*(i+1),s[i+1],s2[i+1]);}}。
第二次数值分析编程报告
第二次数值分析编程报告Code 2：对函数F x = 11+x 2,x ∈[−5,5] 构造牛顿插值多项式p(x)，插值节点为：1.x i =5− 10N i ,i =0,1,2,…,N2.x i =−5− cos(2i +12N +2Π),i =0,1,2,…,N并计算如下误差 max i { f y i −p y i ,y i =i −5,i =0,1,…,100} 对N=5,10,20,40比较以上两组节点的结果。
编程分析：因为拉格朗日型的插值多项式如下：P(x) = c i n i=0 (x −x j )i−1j =0由于在编程题目中已给出了节点和函数表达式，我们可以求出系数y i 和l i x 。
然后利用已求出的拉格朗日插值多项式求出最大误差。
算法：计算c[i]的算法：c[0] = y[0];for k =1 to n dod = x[k] –x[k-1];u = c[k-1];for i = k-2 to 0 step -1 dou = u * (x[k] - x[i]) + c[i];d = d * (x[k] - x[i]);end doc[k] = (y[k] - u)/d;end do对于给定的t值，用下面的算法得到u = p(t) u = c[k];for I = k-1 to 0 step -1 dou = (t –x[i]) * u + c[i];end do以下是用程序跑出的结果：N=5Max error of gird (1): 0.4327Max error of gird (2):0.5559N=10Max error of gird (1):1.9156Max error of gird (2):0.1089N=20Max error of gird (1):58.2781Max error of gird (2):0.0153N=40Max error of gird (1):7.8689e+04Max error of gird (2):2.7386e-04分析：由于上次的代码中我们已经计算了误差，又因为插值多项式具有唯一性，所以我们这次计算出的误差应该和上次一样。
二次拉格朗日插值公式
二次拉格朗日插值公式
二次拉格朗日插值公式是一种用于在给定数据点之间进行插值的方法。
它是拉格朗日插值法的一种形式，用于计算一个函数在一组已知点之间的值。
二次拉格朗日插值公式是通过一个二次多项式来逼近一组数据点的函数值，这个多项式可以用以下公式表示：
f(x) = y0 * L0(x) + y1 * L1(x) + y2 * L2(x)
其中，y0、y1、y2是已知数据点的函数值，L0(x)、L1(x)、L2(x)是拉格朗日基函数，它们的形式如下：
L0(x) = (x - x1) * (x - x2) / ((x0 - x1) * (x0 - x2))
L1(x) = (x - x0) * (x - x2) / ((x1 - x0) * (x1 - x2))
L2(x) = (x - x0) * (x - x1) / ((x2 - x0) * (x2 - x1))
其中，x0、x1、x2是已知数据点的横坐标。
二次拉格朗日插值公式的优点是可以通过一个简单的公式来计算插值多项式，而不需要解线性方程组。
同时，它也有一些缺点，比如插值多项式的次数较低，可能不能很好地逼近复杂的函数。
此外，如果数据点的数量很多，计算过程也会变得非常复杂。
总之，二次拉格朗日插值公式是一种简单而有效的插值方法，可以用于计算函数在一组已知点之间的值。
但是，在使用这种方法时，需要注意数据点的数量和函数的复杂程度，以确保插值结果的准确性。
C#插值法插值法插值法
#include"stdafx.h"#include<stdio.h>#include<stdlib.h>#include<iostream.h>typedef struct data{float x;float y;}Data;//变量x和函数值y的结构Data d[20];float f(int s,int t)//牛顿插值法，用以返回插商{if(t==s+1)return(d[t].y-d[s].y)/(d[t].x-d[s].x);elsereturn(f(s+1,t)-f(s,t-1))/(d[t].x-d[s].x);}float Newton(float x,int count){int n;while(1){cout<<"请输入n值(即n次插值):";//获得插值次数cin>>n;if(n<=count-1)//插值次数不得大于count－1次break;elsesystem("cls");}//初始化t，y，yt。
float t=1.0;float y=d[0].y;float yt=0.0;//计算y值for(int j=1;j<=n;j++){t=(x-d[j-1].x)*t;yt=f(0,j)*t;//cout<<f(0,j)<<endl;y=y+yt;}return y;}float lagrange(float x,int count){float y=0.0;for(int k=0;k<count;k++)//这儿默认为count－1次插值{float p=1.0;//初始化pfor(int j=0;j<count;j++){//计算p的值if(k==j)continue;//判断是否为同一个数p=p*(x-d[j].x)/(d[k].x-d[j].x);}y=y+p*d[k].y;//求和}return y;//返回y的值}void main(){float x,y;int count;while(1){cout<<"请输入x[i],y[i]的组数，不得超过20组:";//要求用户输入数据组数cin>>count;if(count<=20)break;//检查输入的是否合法system("cls");}//获得各组数据for(int i=0;i<count;i++){cout<<"请输入第"<<i+1<<"组x的值:";cin>>d[i].x;cout<<"请输入第"<<i+1<<"组y的值:";cin>>d[i].y;}cout<<"请输入x的值:";//获得变量x的值cin>>x;while(1){int choice=3;cout<<"请您选择使用哪种插值法计算："<<endl;cout<<"(0):退出"<<endl;cout<<"(1):Lagrange"<<endl;cout<<"(2):Newton"<<endl;cout<<"输入你的选择：";cin>>choice;//取得用户的选择项if(choice==2){cout<<"你选择了牛顿插值计算方法，其结果为：";y=Newton(x,count);break;//调用相应的处理函数}if(choice==1){cout<<"你选择了拉格朗日插值计算方法，其结果为：";y=lagrange(x,count);break;//调用相应的处理函数}if(choice==0)break;system("cls");cout<<"输入错误!!!!"<<endl;}cout<<x<<","<<y<<endl;//输出最终结果}。