秦九韶算法matlab程序写法
matlab秦九韶算法程序例子
matlab秦九韶算法程序例子秦九韶算法，又称为秦九韶求值算法，是一种用于求解多项式值的算法。
它可以在O(n)的时间复杂度内计算一个多项式在给定点的值，相对于普通的计算方法而言，具有更高的效率。
本文将以MATLAB语言为例，介绍秦九韶算法的实现过程，并提供一些示例代码。
1. 算法原理秦九韶算法的核心思想是利用累积计算的方式，将多项式的求值过程转化为一个累积乘法的过程。
具体而言，算法通过反复利用上一次的计算结果，不断累积乘以给定点的值，并加上下一个系数，从而逐步求得多项式在给定点的值。
2. 算法实现下面是一个简单的MATLAB函数实现秦九韶算法的例子：```matlabfunction res = evaluatePolynomial(coefficients, x)n = length(coefficients);res = coefficients(n);for i = n-1:-1:1res = res * x + coefficients(i);endend```3. 示例代码下面给出一个示例，假设我们要计算多项式P(x) = 2x^3 + 3x^2 + 4x + 5在x = 2的值，可以使用上述实现的秦九韶算法函数evaluatePolynomial：```matlabcoefficients = [2, 3, 4, 5];x = 2;result = evaluatePolynomial(coefficients, x);disp(result);```运行上述代码，输出结果为33，表示多项式在x = 2的值为33。
4. 复杂度分析根据秦九韶算法的实现，计算多项式在给定点的值的时间复杂度为O(n)，其中n为多项式的阶数。
这是由于算法只需要进行一次遍历，累积乘法的操作次数与多项式的阶数相同。
5. 算法优势相对于普通的计算方法，秦九韶算法具有较高的效率。
在求解多项式值时，传统的计算方法需要进行多次乘法和加法运算，而秦九韶算法通过累积乘法的方式，大大减少了乘法和加法的次数，从而提升了计算效率。
matlab秦九韶算法程序例子
matlab秦九韶算法程序例子Matlab中的秦九韶算法是一种用于快速计算多项式的算法。
在这篇文章中，我将列举十个使用Matlab实现秦九韶算法的例子，并详细解释每个例子的实现过程和结果。
1. 一元多项式求值考虑一个一元多项式P(x) = 2x^3 + 3x^2 + 4x + 5，我们可以使用秦九韶算法来计算P(x)在x=2处的值。
首先，将多项式的系数存储在一个向量coeff中，然后使用秦九韶算法求解：```matlabcoeff = [2, 3, 4, 5];x = 2;result = coeff(1);for i = 2:length(coeff)result = result*x + coeff(i);enddisp(result);```结果为31，即P(2) = 31。
2. 多项式相加考虑两个多项式P(x) = 2x^3 + 3x^2 + 4x + 5和Q(x) = 1x^2 + 2x + 3，我们可以使用秦九韶算法将它们相加。
首先，将两个多项式的系数存储在两个向量coeff1和coeff2中，然后使用秦九韶算法求解：```matlabcoeff1 = [2, 3, 4, 5];coeff2 = [1, 2, 3];result = zeros(1, max(length(coeff1), length(coeff2)));for i = 1:min(length(coeff1), length(coeff2))result(i) = coeff1(i) + coeff2(i);endif length(coeff1) > length(coeff2)result(length(coeff2)+1:end) = coeff1(length(coeff2)+1:end);elseresult(length(coeff1)+1:end) = coeff2(length(coeff1)+1:end);enddisp(result);```结果为[2, 4, 8, 8]，即P(x) + Q(x) = 2x^3 + 4x^2 + 8x + 8。
用秦九韶算法计算多项式的值c语言
用秦九韶算法计算多项式的值c语言多项式是数学中的一个重要概念，它在各个领域都有广泛的应用。
在计算机科学中，多项式的计算也是一个常见的问题。
本文将介绍一种高效的算法——秦九韶算法，用它来计算多项式的值。
一、秦九韶算法的原理秦九韶算法是一种快速计算多项式值的算法。
它的基本思想是将多项式的系数和变量分离，然后通过递推的方式计算多项式的值。
具体来说，假设多项式为：f(x) = a0 + a1x + a2x^2 + ... + anx^n我们可以将其表示为：f(x) = a0 + x(a1 + x(a2 + ... + x(an-1 + anx)...))这样，我们就可以通过递推的方式计算多项式的值。
具体来说，我们可以从最高次项开始，依次计算每一项的值，然后将其累加起来。
这样，我们就可以在O(n)的时间复杂度内计算多项式的值。
二、用c语言实现秦九韶算法下面，我们将用c语言来实现秦九韶算法。
具体来说，我们可以定义一个数组来存储多项式的系数，然后通过循环来计算多项式的值。
代码如下：```c#include <stdio.h>double qinjiushao(double a[], int n, double x) {double result = a[n];for (int i = n - 1; i >= 0; i--) {result = result * x + a[i];}return result;}int main() {double a[] = {1, 2, 3, 4, 5};int n = 4;double x = 2;double result = qinjiushao(a, n, x);printf("f(%lf) = %lf\n", x, result);return 0;}```在这个例子中，我们定义了一个数组a来存储多项式的系数，n表示多项式的最高次数，x表示要计算的多项式的值。
算法案例秦九韶算法 PPT学习教案
为什么说 前一趟的 比较中交 换为0次时 ，排序完 成？
3，2，5， 8， 6 ， 9
S3：如果前一趟的比较中交换的次数为0，说明排序 已完成，否则回到S2。
第8页/共14页
排序的算法 将下面数字按由小到大的顺序排列
8，3，2，5，9，6 请将每一趟的结果写出来
第1趟
8
3
3
3
3
3
3
8
2
2
2
2
2
2
8
所以，当x = 5时，多项式的值等于17255.2
你从中看到了 怎样的规律？ 怎么用程序框 图来描述呢？
第4页/共14页
开始 输入f (x)的系数： a0、a1、a2、a3、a4、a5
输入x0
n=0
v=a5
v= v·x0+a5-n
n < 5? 否 输出v
结束
n=n+1 是
秦九韶算法检验
注意：要想第使5页用/检共验14功页能，请使用前，先要减低宏的安全限制
算法案例秦九韶算法
会计学
1
《数书九章》——秦九韶算法
设 f (x) 是一个n次的多项式
f (x) an xn an1xn1 a1x a0
对该多项式按下面的方式进行改写：
f (x) an xn an1xn1 a1x a0 (an xn1 an1xn2 a1)x a0
这是怎样的一 种改写方式？ 最后的结果是
6
2
3
5
8
9
6
2
3
5
6
8
9
第7页/共14页
排序的算法 将下面数字按由小到大的顺序排列 8，3，2，5，9，6
《秦九韶算法》课件
秦九韶பைடு நூலகம்法的代码示例
} ``` Java实现
秦九韶算法的代码示例
01
```java
02
import java.util.Scanner;
public class Main {
03
秦九韶算法的代码示例
01
02
03
public static void main(String[] args) {
Scanner scanner = new
秦九韶算法的步骤解析
01
确定多项式的最高次项 系数和次数。
02
根据秦九韶算法的公式 ，计算一次多项式的系 数。
03
利用一次多项式求值公 式，计算多项式的值。
04
重复以上步骤，直到求 出所有需要计算的多项 式的值。
秦九韶算法的公式推导
根据多项式求值原理，推导出秦九韶 算法的公式。
利用递归的思想，将高次多项式转化 为一次多项式，推导出秦九韶算法的 公式。
编写代码
按照秦九韶算法的步骤，编写相应的代码。需要注意代码 的健壮性和可读性，以便于后续的维护和调试。
测试代码
通过输入不同的多位数，测试代码的正确性和性能。
秦九韶算法的代码示例
C语言实现 ```c
int main() {
秦九韶算法的代码示例
int n, x = 0, i, d; printf("请输入一个多位数：");
05
秦九韶算法的优缺点
秦九韶算法的优点
01
02
03
高效性
秦九韶算法将多项式求值 问题转化为一系列一元运 算，减少了乘法的次数， 提高了运算效率。
易于编程实现
秦九韶算法的步骤明确， 易于转化为程序代码，便 于计算机实现。
算法案例(秦九韶算法)
算法的步骤和流程
01
02
03
04
2. 将 $a_{i+1}$ 加到 $v$ 中。 3. 将 $v$ 存储在变量 $P$ 中。
步骤3：返回 $P$ 作为多项 式的值。
通过以上步骤，秦九韶算法可以 在 $O(n)$ 的时间内计算出一元 多项式的值，其中 $n$ 是多项式 的次数。与直接使用常规的求值 方法相比，秦九韶算法可以显著 减少乘法的次数，从而提高计算
缺点
对大系数多项式不适用
秦九韶算法适用于系数和次数都很大的多项式，但如果多项式的 系数非常大，可能会导致数值溢出或下溢，影响计算精度。
需要额外的存储空间
秦九韶算法需要存储中间结果，如果多项式的次数很大，需要额外 的存储空间。
对某些特殊多项式不适用
秦九韶算法不适用于某些特殊的多项式，如常数、一次多项式等。
秦九韶算法的应用场景
数值分析
秦九韶算法在数值分析中广泛应用于求解多项式方程的根，以及进行 数值积分和微分等计算。
科学计算
在科学计算领域，秦九韶算法被用于计算物理、化学、工程等领域中 的多项式函数值，以及进行数据拟合和插值等操作。
计算机图形学
在计算机图形学中，秦九韶算法被用于计算光线追踪和纹理映射等算 法中的多项式函数值，以提高渲染效率和精度。
05
秦九韶算法的优缺点
优点
高效性
秦九韶算法是一种快速算法，可以在多项式 时间内完成计算，比直接计算更高效。
易于编程实现
秦九韶算法的步骤明确，易于编程实现，可 以方便地应用于计算机程序中。
数值稳定性
秦九韶算法在计算过程中可以减少舍入误差， 提高数值稳定性。
适用范围广
秦九韶算法适用于多项式的系数和次数都很 大的情况，具有较广的适用范围。
matlab程序总结
程序总结1、简单计算A:x 255=x.x (x)B:x 255=x ·x 2·x 4·x 8·x 16·x 32·x 64·x 1282.0111)(a x a x a x a x P n n n n n ++++=--算法1 (输入a (i )(i =0,1，…,n),x ;输出 算法2 （秦九韶算法）3.s=0;for i=1:ns=s+abs(x(i)); End4.s=0; s=0; for i=1:n for i=1:n s=s+x(i)^2; s=s+x(i)*x(i); end end s=sqrt(s) s=sqrt(s)5.s=0; for i=1:nif abs(x(i))>s,s=abs(x(i)); end end();;1:7*;*;Matlab s x y x for i s s s y y B s end=====算法1(0)1:*()*t u a for i n t x tu u a i t end =====+()1:1:0*()p a n for k n p x p a k end==--=+1111n ii x x =-=∑计算向量的范数程序122212()2ni i x x =-=∑计算向量的范数程序1m 3ax ii nxx ∞≤≤∞-=计算向量的程范数序6. LU分解的matlap程序function A=lud(A)%功能：对方阵A作三角分解A=LU,其中，% L为单位下三角阵，U为上三角阵，%输入：方阵A。
%输出：紧凑存储A=[L\U].%注意：当A的主元=0时退出Matlabfor k=1:n-1for i=k+1:nif A(k,k) ==0 quit; endA(i,k) =A(i,k)/ A(k,k);A(i,k+1:n)= A(i,k+1:n)- A(i,k) *A(k,k+1:n);endend7. 列主元Gauss消元法Lupd.m%功能：对方阵A作列主元三角分解PA=LU,其中，% L为单位下三角阵，U为上三角阵，排列阵P%用向量p表示。
数值计算C语言常用小程序
1、秦九韶算法2、二分法3、拉格朗日插值4、埃特金算法5、复化梯形法6、复化辛甫生算法7、二阶龙格库塔方法8、四阶龙格库塔方法9、改进的欧拉方法10、迭代法11、埃特金加速方法：12、牛顿迭代法13、追赶法14、雅克比迭代15、蛋白质设计：17高斯消去法:1、秦九韶算法利用秦九韶算法求多项式，在x=3时的值。
程序：#include<>#include<>void main(){float a[100],v,x;int n,i,k;scanf("%d%f",&n,&x);for(i=0;i<=n;i++)scanf("%f",&a[i]);v=a[n];k=1;do{v=x*v+a[n-k];k=k+1;}while(k<=n);printf("v=%f",v);}运行结果：2、二分法用二分法求方程法x*x*x-x-1=0在[1,2]内的近似根，要求误差不超过#include<>#include<>float fun(float);void main(){float a,b,c,x,y,y1;scanf("%f%f%f",&a,&b,&c);y1=fun(a);do{x=(a+b)/2;y=fun(x);{if(y*y1>0)a=x;elseb=x;}}while((b-a)>=c);printf("%f,%f\n",x,y);}float fun(float m) {float n;n=m*m*m-m-1;return(n);}运行结果：3、拉格朗日插值程序：#include<>main(){float a,b,t,x[100],y[100]; int n,i,j,k;scanf("%f%d",&a,&n); for(i=0;i<=n;i++)scanf("%f%f",&x[i],&y[i]); k=0;b=0;for(k=0;k<=n;k++){t=1;for(j=0;j<=n;j++){if(j!=k)t=t*(a-x[j])/(x[k]-x[j]);}b=b+t*y[k];}printf("%f\n",b);}4、埃特金算法程序：#include<>#include<>main(){float a,b,c,x[100],y[100]; int i,j,n,k;scanf("%d%f",&n,&a); for(i=0;i<=n;i++)scanf("%f%f",&x[i],&y[i]); for(k=1;k<=n;k++){for(i=k;i<=n;i++)y[i]=y[k-1]+(y[i]-y[k-1])*(a-x[k-1])/(x[i]-x[k-1]);} printf("%f\n",y[n]);}5、复化梯形法设,用复化梯形法求积分的近似值程序：#include<>#include<>double fun(double);void main(){double a,b,h,s,x,y;int n,k;scanf("%lf%lf%d",&a,&b,&n);h=(b-a)/n;s=0;x=a;y=fun(x);for(k=1;k<=n;k++){s=s+fun(x);x=x+h;s=s+fun(x);}s=(h/2)*s;printf("s=%lf\n",s);}double fun(double m){double n;n=exp(-m)*sin(4*m)+1;return(n);}运行结果：6、复化辛甫生算法设,用复化辛甫生法求积分的近似值程序：#include<>#include<>double fun(double);void main(){double a,b,h,s,x,y;int n,k;scanf("%lf%lf%d",&a,&b,&n);h=(b-a)/n;s=0;x=a;y=fun(x);for(k=1;k<=n;k++){s=s+fun(x);x=x+h/2;s=s+4*fun(x);x=x+h/2;s=s+fun(x);}s=(h/6)*s;printf("s=%lf\n",s);}double fun(double m){double n;n=exp(-m)*sin(4*m)+1;return(n);}运行结果：7、二阶龙格库塔方法求解初值问题：取h=程序：#include<>#include<>float fun(float,float);void main(){float h,x0,y0,x1,y1,k1,k2;int n,N;scanf("%f%f%f%d",&x0,&y0,&h,&N); n=1;for(n=1;n<=N;n++){x1=x0+h;k1=fun(x0,y0);k2=fun(x0+h/2,y0+h/2*k1);y1=y0+h*k2;printf("%f,%f\n",x1,y1);x0=x1;y0=y1;}}float fun(float a,float b){float m;m=b-2*a/b;return(m);}运行结果：8、四阶龙格库塔方法求解初值问题：取h=程序：#include<>#include<>float fun(float,float);void main(){float h,x0,y0,x1,y1,k1,k2,k3,k4;int n,N;scanf("%f%f%f%d",&x0,&y0,&h,&N); n=1;for(n=1;n<=N;n++){x1=x0+h;k1=fun(x0,y0);k2=fun(x0+h/2,y0+h/2*k1);k3=fun(x0+h/2,y0+h/2*k2);k4=fun(x1,y0+h*k3);y1=y0+h/6*(k1+2*k2+2*k3+k4); printf("%f,%f",x1,y1);x0=x1;y0=y1;}}float fun(float a,float b){float m;m=b-2*a/b;return(m);}运行结果：9、改进的欧拉方法求解初值问题：程序：#include<>#include<>float fun(float,float);void main(){float x0,y0,h,x1,y1,yp,yc;int n,N;scanf("%f%f%f%d",&x0,&y0,&h,&N);for(n=1;n<=N;n++){x1=x0+h;yp=y0+h*fun(x0,y0);yc=y0+h*fun(x1,yp);y1=(yp+yc)/2;printf("%f,%f",x1,y1);x0=x1;y0=y1;}}float fun(float a,float b){float m;m=b-2*a/b;return(m);}运行结果：10、迭代法P131 例2 用迭代法求方程在附近的一个根，要求精度为程序：#include<>#include<>float fun(float);void main(){float x0,x1,c;int k,N;scanf("%f%f%d",&x0,&c,&N);for(k=1;k<=N;k++){x1=fun(x0);printf("%f\n",x1);if(fabs(x1-x0)<c) break;x0=x1;}if(k-1==N)printf("Failure!\n");}float fun(float m){float n;n=exp(-m);return(n);}运行结果：11、埃特金加速方法：程序：#include<>#include<>float fun(float);void main(){float x0,x1,x2,c;int k,N;scanf("%f%f%d",&x0,&c,&N);for(k=1;k<=N;k++){x1=fun(x0);x2=fun(x1);x2=x2-(x2-x1)*(x2-x1)/(x2-2*x1+x0); if(fabs(x2-x0)<c){printf("%f\n",x2);break;}x0=x2;}if(k-1==N)printf("Failure!\n");}float fun(float m){float n;n=exp(-m);return(n);}运行结果：12、牛顿迭代法：例5、用牛顿法解方程牛顿公式为：，取x=程序：#include<>#include<>float fun(float);float ff(float);void main(){float x0,x1,c;int k,N;scanf("%f%f%d",&x0,&c,&N);for(k=1;k<=N;k++){if(ff(x0)!=0){x1=x0-fun(x0)/ff(x0);printf("%f\n",x1);if(fabs(x1-x0)<c) break;x0=x1; }elseprintf("****");}if(k==N)printf("Failure!\n");}float fun(float m){float n;n=m-exp(-m);return(n);}float ff(float m){float n;n=1+m;return(n);}运行结果：13、追赶法：.用追赶法求解下列方程组：程序：#include<>#include<>void main(){float a[100],b[100],c[100],d[100],t; int i,n;scanf("%d",&n);for(i=2;i<=n;i++)scanf("%f",&a[i]);for(i=1;i<=n;i++)scanf("%f",&b[i]);for(i=1;i<=n-1;i++)scanf("%f",&c[i]);for(i=1;i<=n;i++)scanf("%f",&d[i]);c[1]=c[1]/b[1];d[1]=d[1]/b[1];for(i=2;i<n;i++){t=b[i]-c[i-1]*a[i];c[i]=c[i]/t;d[i]=(d[i]-d[i-1]*a[i])/t;}d[n]=(d[n]-d[n-1]*a[n])/(b[n]-c[n-1]*a[n]); printf("%f\n",d[n]);for(i=n-1;i>=1;i--){d[i]=d[i]-c[i]*d[i+1];printf("%f\n",d[i]);}}运行结果：14、雅克比迭代程序：#include<>#include<>#define N 50#define M 4void main(){double x[M],y[M],a[M][M],b[M],d[M],c,t; double ff(double [],int);int k,i,j,n;n=M-1;scanf("%lf",&c);for(i=0;i<=n;i++){scanf("%lf",&x[i]);scanf("%lf",&b[i]);}for(i=0;i<=n;i++)for(j=0;j<=n;j++)scanf("%lf",&a[0][i*M+j]);for(k=1;k<=N;k++){for(i=1;i<=n;i++){for(j=1,t=0;j<=n;j++){if(j==i)continue;elset=t+a[i][j]*x[j];}y[i]=(b[i]-t)/a[i][i];}for(i=1;i<=n;i++)d[i]=fabs(x[i]-y[i]);t=ff(d,n+1);if(t<c) break;elsefor(i=1;i<=n;i++)x[i]=y[i];}if(k==N)printf("Failure!\n");if(k<N){printf("k=%d\n",k);for(i=1;i<=n;i++)printf("y[i]=%f\n",y[i]);}}double ff(double a[],int n){double p;int t;p=a[1];for(t=2;t<n;t++){if(p<a[t])p=a[t];}return(p);}运行结果：15、蛋白质设计：程序：#include <>#include <>#include <>void main(){printf("横坐标纵坐标竖坐标\n"); FILE *fp;char c[100],x[3000][7],y[3000][7],z[3000][7]; float a[3000],b[3000],d[3000],r[3000];int i,k=0,j,n=0,m,p;float X[3000],Y[3000],Z[3000],s1=0,s2=0,s3=0,av_x,av_y,av_z; fp=fopen("1a1c.pdb","r");for(i=0;i<=10000;i++){fgets(c,81,fp);if(c[0]=='A'&&c[1]=='T'&&c[2]=='O'&&c[3]=='M'){for(j=0;j<6;j++){x[k][j]=c[32+j];printf("%c",x[k][j]);}printf(" ");for(j=0;j<6;j++){y[k][j]=c[40+j];printf("%c",y[k][j]);}printf(" ");for(j=0;j<6;j++){z[k][j]=c[48+j];printf("%c",z[k][j]);}printf(" ");X[k]=atof(x[k]);s1+=X[k];Y[k]=atof(y[k]);s2+=Y[k];Z[k]=atof(z[k]);s3+=Z[k];printf("\n");k++;if(c[77]=='C') n++;}}av_x=s1/k;av_y=s2/k;av_z=s3/k;printf("共有:%d\n",k+1);printf("av_x=%f,av_y=%f,av_z=%f\n",av_x,av_y,av_z);printf("C原子个数为:%d\n",n);printf("平移原点后的坐标:\n");for(m=0;m<k;m++){a[m]=X[m]-av_x;printf("%f ",a[m]);b[m]=Y[m]-av_y;printf("%f ",b[m]);d[m]=Z[m]-av_z;printf("%f ",d[m]);r[m]=sqrt(a[m]*a[m]+b[m]*b[m]+d[m]*d[m]);printf("%f ",r[m]); printf("\n");}}17高斯消去法:#include ""#include""main(){double a[3][3]={1,1,1,0,4,-1,2,-2,1},b[3]={6,5,1},x[10]={0};int i,j,k,n=3;for(k=0;k<n-1;k++){ for(i=k+1;i<n;i++){ for(j=k+1;j<n;j++){ a[i][j]=a[i][j]-a[k][j]*a[i][k]/a[k][k];}b[i]=b[i]-b[k]*a[i][k]/a[k][k];}}x[n-1]=b[n-1]/a[n-1][n-1];for(i=2;i<=n;i++){ k=n-i;for(j=k+1;j<n;j++){ x[k]+=a[k][j]*x[j];}x[k]=(b[k]-x[k])/a[k][k];}for(k=0;k<n;k++)printf("x[%d]=%f",k,x[k]);}。
案例2秦九韶算法
并行化优化效果
通过实验验证，并行化实现的秦 九韶算法在处理大规模数值计算 问题时，能够显著提高计算速度， 减少计算时间。
算法的误差分析
误差来源
秦九韶算法中的误差主要来源于舍入误差和截断误差。舍 入误差是由于计算机浮点数的表示精度限制而引起的，截 断误差是由于近似计算而引起的。
误差传播
误差在秦九韶算法的计算过程中会累积和传播，对计算结 果的精度产生影响。误差传播的分析有助于了解算法的精 度损失情况。
扩展应用前景
随着科学计算和工程领域中大规模数值计算问题的不断涌现，秦九韶 算法的扩展应用前景广阔，具有重要的实际意义和价值。
05 秦九韶算法的未来发展与 展望
算法的进一步研究与完善
深入研究秦九韶算法 的数学原理，探索其 更广泛的应用场景。
结合现代计算机技术， 开发更高效的秦九韶 算法实现方式。
针对算法的缺陷和不 足，进行改进和优化， 提高算法的效率和准 确性。
算法在其他领域的应用探索
01
在数值分析、计算物理、工程优化等领域探索秦九 韶算法的应用可能性。
02
结合人工智能、机器学习等技术，将秦九韶算法应 用于数据分析和模式识别等领域。
03
探索秦九韶算法在金融、经济、社会科学等领域的 应用，为决策提供支持。
秦九韶算法对数学发展的影响
1
秦九韶算法的提出和发展，丰富了数学理论体系， 为后续数学研究提供了新的思路和方法。
秦九韶算法案例分析
contents
目录
• 秦九韶算法简介 • 秦九韶算法的原理 • 秦九韶算法案例展示 • 秦九韶算法的改进与优化 • 秦九韶算法的未来发展与展望
01 秦九韶算法简介
秦九韶算法的定义
秦九韶算法是一种用于计算多项式的 算法，它将多项式计算转化为一系列 的乘法和加法操作，从而提高了计算 的效率。
matlab第二次
Matlab素质拓展课第二次作业第二次课知识点if 选择语句for while 循环语句子函数（多个输入参数输出参数）递归二分法秦九韶算法等3.3 写一个名为nexthour的函数，接收一个整数参数，该参数是一天内的某个小时，然后返回下一个小时。
假定是12小时制，所以例子中12的下一个小时是1.% 3.3 写一个名为nexthour的函数，% 接收一个整数参数，该参数是一天内的某个小时，然后返回下一个小时。
% 假定是12小时制，所以例子中12的下一个小时是1.function y=nexthour(n)if n>=1&&n<=11y=n+1;elseif n==12y=1;elsey=-1;disp('输入错误！');endend3.6 写一个脚本，提示用户输入分数的分子和分母。
如果分母是0，则打印错误信息，指出0不能做分母。
如果分母不是0，则打印分数的结果。
% 3.6 写一个脚本，提示用户输入分数的分子和分母。
% 如果分母是0，则打印错误信息，指出0不能做分母。
% 如果分母不是0，则打印分数的结果。
clc;clear;fenzi=input('请输入分子:');fenmu=input('\n请输入分母:');if fenmu==0disp('打印错误！分母不能为0！')elsefprintf('分数=%d/%d\n',fenzi,fenmu);end3.11 写一个函数createMToN，它能够创建并返回一个从m到n的整数组成的向量（m是第一个输入参数，n是第二个），不管m是小于n还是大于n。
如果m等于n，该向量正好是1*1的，或者说是标量。
%dy_chapter3_11.m cerateMToNfunction vec=dy_chapter3_11(m,n)if m>nvec=m:-1:n;elseif mvec=m:n;elsevec=m;end3.17 写一个脚本，它能生产一个随机整数，并且打印该随机整数是一个偶数还是一个奇数。
matlab 秦和韶方法求多项式
在数值分析领域中，MATLAB中的秦和韶方法是一种常用的求多项式值的数值计算方法。
这种方法通过递推的方式，可以高效地求解多项式在给定点处的值，是数值计算中的重要工具之一。
1. 秦和韶方法的原理秦和韶方法是一种用于计算多项式在某一点的值的数值计算方法。
其基本原理是通过递推的方式，将多项式的系数依次代入到一个递推公式中，从而得到多项式在指定点处的值。
这种方法可以大大减少计算量，提高计算效率。
对于一个n次多项式f(x)=a0x^n + a1x^(n-1) + ... + an-1x + an，假设要计算多项式在点x=c处的值，秦和韶方法的递推公式可以表示为：f(c) = an + c(an-1 + c(an-2 + ... + c(a1 + can)...))2. 秦和韶方法的实现在MATLAB中，可以通过编写相应的函数来实现秦和韶方法。
首先需要将多项式的系数表示为一个数组，然后利用循环或递归的方式，根据秦和韶方法的递推公式依次计算多项式在指定点处的值。
以下是一个简单的MATLAB代码示例，实现了秦和韶方法的多项式求值：```matlabfunction result = evaluate_polynomial(coefficients, point)n = length(coefficients);result = coefficients(n);for i = n-1:-1:1result = result * point + coefficients(i);endend```在这个代码中，coefficients为多项式的系数数组，point为要求多项式值的指定点。
通过循环计算，即可得到多项式在指定点处的值。
3. 秦和韶方法的应用秦和韶方法在实际应用中具有广泛的用途，特别是在科学计算和工程技术领域。
在信号处理、数值模拟、图像处理等领域，多项式的求值是一个常见的计算问题，而秦和韶方法可以提供高效的计算方式。
计算方法MATLAB程序样例
1.利用共轭梯度法求解大规模稀疏方程组1.1.算法原理共轭梯度法是把求解线性方程组的问题转化为求解一个与之等价的二次函数极小值的问题。
对于特定的线性方程组来说，选取与之等价的二次函数之后，可以从任意给定的初始点出发，沿一组关于矩阵A 的共轭方向进行线性搜索，在无舍入误差的假定下，最多迭代n次（其中n为矩阵A 的阶数），就可以求得二次函数的极小点，也就求得了线性方程组A x=b的解。
对于特定线性方程组A x=b，其对应的n元二次函数为：f(x)=12x T Ax−b T x其中A为对称正定矩阵，二次函数的梯度为：∇f(x)=Ax+b 通过一系列的数学推导，最终可以得到共轭梯度的计算公式：{d(0)=r(0)=b−Ax(0)αk=r(k)T d(k)d(k)T Ad(k)x(k+1)=x(k)+αk d(k) r(k+1)=b−Ax(k+1)βk=−r(k+1)T Ad(k)d(k)T Ad(k)d(k+1)=r(k+1)+βk d(k)共轭梯度法在形式上具有迭代法的特征，即给定初始向量x(0)后，由迭代格式x(k+1)=x(k)+αk d(k)能够产生迭代序列x(1)，x(2)，x(3)，最终得到满足约束条件的解。
而该方法中关键的两点是，确定上述迭代格式中的搜索方向d(k)和最佳步长αk。
实际上，搜索方向d(k)是关于矩阵A的共轭向量,在迭代中逐步构造之。
步长αk的确定原则是给定迭代点x(k)和搜索方向d(k)后，要求选取非负实数αk使得f(x(k)+αk d(k))达到最小。
因此，由该算法原理可得共轭梯度法的程序流程图如下图所示。
图 1.1共轭梯度法程序流程图1.2.程序使用说明针对相关问题的源程序及注释如下：clc;clear all;format long;n=100;%A的阶数A=zeros(100);A=diag(repmat([1],1,n-1),1)+diag(repmat([1],1,n-1),-1)+diag(repmat([-2],1,n));%构建三对角矩阵b=zeros(n,1);b(1,1)=-1;b(n,1)=-1;x0=zeros(n,1);d0=b-A*x0;r0=b-A*x0;D0=d0;R0=r0;X0=x0;C=norm(A)*norm(inv(A));%共轭梯度法¨for k=1:3*na0=(r0.'*d0)/(d0.'*A*d0);x=x0+a0*d0;r=b-A*x;beta=-(r.'*A*d0)/(d0.'*A*d0);d=r+beta*d0;x0=x;r0=r;d0=d;if norm(r)< 1e-9seigm(k)=norm(r);breakelseseigm(k)=norm(r);endendR=r0;X=x0;%最速下降法¨r0=R0;d0=D0;x0=X0;%读取初始向量初始残差与初始方向for k=1:3*na0=(r0.'*r0)/(r0.'*A*r0);x=x0-a0*r0;r=A*x-b;f=x-x0;x0=x;r0=r;if norm(f)< 1e-9seigm1(k)=norm(r);breakelseseigm1(k)=norm(r);endendR1=r0;X1=x0;m=1:length(seigm);M=1:length(seigm1);figure;plot(m,log(seigm),'r');%误差对数的变化曲线hold on;grid on;plot(M,log(seigm1),'b');hold on;grid on;legend('¹²éîÌݶȷ¨','×îËÙϽµ·¨','fontname','ËÎÌå');运行上述程序可得共轭梯度法和最速下降法误差收敛速度图。
算法案例---秦九韶算法
+
变形后 x 的系数
4
22 113.5 564.9 2826.2 14130.2 *5
思考：让学生回顾整个计算过程，用此种方法一共进行了多少次乘法、加法运算？ 点评：一共进行了 5 次乘法，5 次加法运算，相比较前两种做法，此做法更快、更方便，而 且在计算过程中，只与多项式的系数有关。 这种算法就是“秦九韶算法”，在此可以介绍下秦九韶生平。【见附页】 （二）研探新知
数学四大家。其父秦季栖，进士出身，官至上部郎中、秘书少监。
秦九韶聪敏勤学。
宋绍定四年（1231），秦九韶考中进士，先后担任县尉、通判、参议官、州守、同农、寺丞
等职。先后在湖北、安徽、江苏、浙江等地做官，1261 年左右被贬至梅州（今广东梅县），
不久死于任所。他在政务之余，对数学进行虔心钻研，并广泛搜集历学、数学、星象、音律、
秦九韶所发明的“大衍求一术”，即现代数论中一次同余式组解法，是中世纪世界数学 的最高成就，比西方 1801 年著名数学家高斯（Gauss，1777―1855 年）建立的同余理论早 554 年，被西方称为“中国剩余定理”。秦九韶不仅为中国赢得无尚荣誉，也为世界数学作 出了杰出贡献。 3、秦九韶的任意次方程的数值解领先霍纳 572 年
问题 1：怎样用秦九韶算法求一般的多项式 f (x) an x n an1x n1 a1x a0 当
x=x0 时的值？ 类似上述方法，将多项式变形为：
f (x) an x n an1x n1 an2 x n2 a1x a0 (an x n1 an1 x n2 an2 x n3 a1 )x a0 ((an x n2 an1x n3 a2 )x a1 )x a0 (((an x an1 )x an2 )x a1 ) a0
数值计算方法实验指导(Matlab版)讲解
《数值计算方法》实验指导（Matlab版）肇庆学院数学与统计学学院计算方法课程组《数值计算方法》实验1报告班级： 20xx 级XXXXx 班 学号： 20xx2409xxxx 姓名： XXX 成绩：1. 实验名称实验1 算法设计原则验证（之相近数相减、大数吃小数和简化计算步骤） 2. 实验题目(1) 取1610=z ，计算z z -+1和)1/(1z z ++，验证两个相近的数相减会造成有效数字的损失．(2) 按不同顺序求一个较大的数（123）与1000个较小的数（15310-⨯）的和，验证大数吃小数的现象．(3) 分别用直接法和秦九韶算法计算多项式n n n n a x a x a x a x P ++++=--1110)(在x =1.00037处的值．验证简化计算步骤能减少运算时间．对于第(3)题中的多项式P (x )，直接逐项计算需要2112)1(+=+++-+n n n 次乘法和n 次加法，使用秦九韶算法n n a x a x a x a x a x P ++++=-)))((()(1210则只需要n 次乘法和n 次加法． 3. 实验目的验证数值算法需遵循的若干规则． 4. 基础理论设计数值算法时，应避免两个相近的数相减、防止大数吃小数、简化计算步骤减少运算次数以减少运算时间并降低舍入误差的积累．两相近的数相减会损失有效数字的个数，用一个大数依次加小数，小数会被大数吃掉，乘法运算次数太多会增加运算时间． 5. 实验环境操作系统：Windows xp ； 程序设计语言：Matlab6. 实验过程(1) 直接计算并比较；(2) 法1：大数逐个加1000个小数，法2：先把1000个小数相加再与大数加； (3) 将由高次项到低次项的系数保存到数组A[n]中，其中n 为多项式次数．7. 结果与分析(1) 计算的z z -+1= ，)1/(1z z ++ ．分析：(2) 123逐次加1000个6310-⨯的和是 ，先将1000个6310-⨯相加，再用这个和与123相加得．分析：(3) 计算次的多项式：直接计算的结果是，用时；用秦九韶算法计算的结果是，用时．分析：8. 附录：程序清单(1) 两个相近的数相减．%*************************************************************%* 程序名：ex1_1.m *%* 程序功能：验证两个相近的数相减会损失有效数字个数*%*************************************************************z=1e16;x,y======================================================================(2) 大数吃小数%*************************************************************%* 程序名：ex1_2.m *%* 程序功能：验证大数吃小数的现象. *%*************************************************************clc; % 清屏clear all; % 释放所有内存变量format long; % 按双精度显示浮点数z=123; % 大数t=3e-15; % 小数x=z; % 大数依次加小数% 重复1000次给x中加上ty=0; % 先累加小数% 重复1000次给y中加上ty=z + y; % 再加到大数x,y======================================================================(3) 秦九韶算法%*************************************************************%* 程序名：ex1_3.m *%* 程序功能：验证秦九韶算法可节省运行时间. *%*************************************************************clc; % 清屏clear all; % 释放所有内存变量format long; % 按双精度显示浮点数A=[8,4,-1,-3,6,5,3,2,1,3,2,-1,4,3,1,-2,4,6,8,9,50,-80,12,35,7,-6,42,5,6,23,74,65,55,80,78,77,98,56]; A(10001)=0; % 扩展到10001项，后面的都是分量0% A为多项式系数,从高次项到低次项x=1.00037;n=9000; % n为多项式次数% 直接计算begintime=clock; % 开始执行的时间% 求x的i次幂% 累加多项式的i次项endtime=clock; % 结束执行的时间time1=etime(endtime,begintime); % 运行时间disp('直接计算');disp(['p(',num2str(x),')=',num2str(p)]);disp([' 运行时间: ',num2str(time1),'秒']);% 秦九韶算法计算begintime=clock; % 开始执行的时间% 累加秦九韶算法中的一项endtime=clock; % 结束执行的时间time2=etime(endtime,begintime); % 运行时间disp(' ');disp('秦九韶算法计算');disp(['p(',num2str(x),')=',num2str(p)]);disp([' 运行时间: ',num2str(time2),'秒']);《数值计算方法》实验1报告班级： 20xx 级XXXXx 班 学号： 20xx2409xxxx 姓名： XXX 成绩：1. 实验名称实验1 算法设计原则验证（之数值稳定性） 2. 实验题目 计算定积分⎰==-1110,1,0,d n x e xI x nn ，分别用教材例1-7推导出的算法A 和B ，其中：算法A ：⎩⎨⎧≈-=-6321.0101I nI I n n 算法B ：⎪⎩⎪⎨⎧≈-=-0)1(1101I I nI n n 验证算法不稳定时误差会扩大．3. 实验目的验证数值算法需遵循的若干规则． 4. 基础理论设计数值算法时，应采用数值稳定性好的算法．数值稳定的算法，误差不会放大，甚至会缩小；而数值不稳定的算法会放大误差． 5. 实验环境操作系统：Windows xp ； 程序设计语言：Matlab6. 实验过程分别用数组IA[ ]和IB[ ]保存两种算法计算的结果． 7. 结果与分析8. 附录：程序清单%*************************************************************%* 程序名：ex1_4.m *%* 程序功能：验证数值稳定性算法可控制误差. *%*************************************************************clc; % 清屏clear all; % 释放所有内存变量format long; % 按双精度显示浮点数I=[0.63212055882856, 0.36787944117144, 0.26424111765712, 0.20727664702865, ...0.17089341188538, 0.14553294057308, 0.12680235656154, 0.11238350406938, ... 0.10093196744492, 0.09161229300662, 0.08387707010843];% 保留14位小数的精确值, …是Matlab中的续行符% 算法AIA(1) = 0.6321; % Matlab下标从1开始，所以要用IA(n+1)表示原问题中的I(n）% 算法Bdisp('n 算法A 算法B 精确值');for n=1:11fprintf('%2d %14.6f %14.6f %14.6f\n',n-1,IA(n),IB(n),I(n));end% n显示为2位整数, 其它显示为14位其中小数点后显示6位的小数《数值计算方法》实验1报告班级： 20xx 级XXXXx 班 学号： 20xx2409xxxx 姓名： XXX 成绩：1. 实验名称实验1 算法设计原则（除数绝对值不能太小） 2. 实验题目将线性方程组增广矩阵利用初等行变换可化为⎪⎪⎭⎫⎝⎛→-⎪⎪⎭⎫ ⎝⎛→-⎪⎪⎭⎫ ⎝⎛''0'0''02221112'12221121112222211121122121121b a b a r r b a b a a r r b a a b a a a a a a 由此可解得'/',/'22221111a b x a b x ==．分别解增广矩阵为161011212-⎛⎫ ⎪⎝⎭和162121011-⎛⎫⎪⎝⎭的方程组，验证除数绝对值远小于被除数绝对值的除法会导致结果失真． 3. 实验目的验证数值算法需遵循的若干规则． 4. 基础理论设计数值算法时，应避免除数绝对值远小于被除数绝对值的除法，否则绝对误差会被放大，使结果失真． 5. 实验环境操作系统：Windows xp ； 程序设计语言：Matlab6. 实验过程用二维数组A 和B 存放方程组的增广矩阵，利用题目所给初等行变换求解方程组． 7. 结果与分析第1种顺序的方程组的解为x = ，y = ；第2种顺序的方程组的解为x = ，y = ． 分析：8. 附录：程序清单%************************************************************* %* 程 序 名：ex1_5.m * %* 程序功能：验证除数的绝对值太小可能会放大误差. * %*************************************************************clc;A=[1e-16, 1, 1; 2, 1, 2];B=[2, 1, 2; 1e-16, 1, 1]; % 增广矩阵% 方程组A% m = - a_{21}/a_{11} 是第2行加第1行的倍数% 消去a_{21}% m = - a_{12}/a_{22} 是第1行加第2行的倍数% 消去a_{12}, 系数矩阵成对角线% 未知数x1的值% 未知数x2的值disp(['方程组A的解: x1=',num2str(A(1,3)),', x2=',num2str(A(2,3))]);disp(' ');% 方程组B% m = - b_{21}/b_{11} 是第2行加第1行的倍数% 消去b_{21}% m = - b_{12}/b_{22} 是第1行加第2行的倍数% 消去b_{12}, 系数矩阵成对角线% 未知数x1的值% 未知数x2的值disp(['方程组B的解: x1=',num2str(B(1,3)),', x2=',num2str(B(2,3))]);《数值计算方法》实验2报告班级： 20xx 级XXXXx 班 学号： 20xx2409xxxx 姓名： XXX 成绩：1. 实验名称实验2 非线性方程的迭代解法(之简单迭代法) 2. 实验题目用简单迭代法求方程010423=-+x x 在区间[1,2]内的一个实根，取绝对误差限为410-．3. 实验目的掌握非线性方程的简单迭代法． 4. 基础理论简单迭代法：将方程0)(=x f 改写成等价形式)(x x ϕ=，从初值0x 开始，使用迭代公式)(1k k x x ϕ=+可以得到一个数列，若该数列收敛，则其极限即为原方程的解．取数列中适当的项可作为近似解． 5. 实验环境操作系统：Windows xp ； 程序设计语言：Matlab 6. 实验过程7. 结果与分析8. 附录：程序清单班级： 20xx 级XXXXx 班 学号： 20xx2409xxxx 姓名： XXX 成绩：1. 实验名称实验2 非线性方程的迭代解法(之Newton 迭代法) 2. 实验题目用Newton 迭代法求方程010423=-+x x 在区间[1,2]内的一个实根，取绝对误差限为410-．3. 实验目的掌握求解非线性方程的Newton 迭代法． 4. 基础理论Newton 迭代法：解方程0)(=x f 的Newton 迭代公式为)(')(1k k k k x f x f x x -=+．5. 实验环境操作系统：Windows xp ； 程序设计语言：Matlab 6. 实验过程7. 结果与分析8. 附录：程序清单班级： 20xx 级XXXXx 班 学号： 20xx2409xxxx 姓名： XXX 成绩：1. 实验名称实验2 非线性方程的迭代解法(之对分区间法) 2. 实验题目用对分区间法求方程310x x --=在区间[1, 1.5]内的一个实根，取绝对误差限为410-． 3. 实验目的掌握求解非线性方程的对分区间法． 4. 基础理论对分区间法：取[a ，b ]的中点p ，若f (p ) ≈ 0或b – a < ε，则p 为方程0)(=x f 的近似解； 若f (a ) f (p ) < 0，则说明根在区间取[a ，p ]中；否则，根在区间取[p ，b ]中．将新的有根区间记为 [a 1，b 1]，对该区间不断重复上述步骤，即可得到方程的近似根． 5. 实验环境操作系统：Windows xp ； 程序设计语言：Matlab 6. 实验过程用宏定义函数f (x )；为了循环方便，得到的新的有根区间始终用[a ，b ]表示； 由于新的有根区间可能仍以a 为左端点，这样会反复使用函数值f (a )，为减少运算次数，将这个函数值保存在一个变量fa 中；同样在判断新的有根区间时用到函数值f (p )，若新的有根区间以p 为左端点，则下一次用到的f (a )实际上就是现在的f (p )，为减少运算次数，将这个函数值保存在一个变量fp 中．算法的伪代码描述：Input ：区间端点a ，b ；精度要求（即误差限）ε；函数f （x ）；最大对分次数N7. 结果与分析8. 附录：程序清单说明: 源程序中带有数字的空行，对应着算法描述中的行号%**********************************************************%* 程序名：Bisection.m *%* 程序功能：使用二分法求解非线性方程. *%**********************************************************f=inline('x^3-x-1'); % 定义函数f(x)a=input('有根区间左端点: a=');b=input('右端点:b=');epsilon=input('误差限:epsilona=');N=input('最大对分次数: N=');1 % 对分次数计数器n置12 % 左端点的函数值给变量fafprintf('\n k p f(p) a(k) f(a(k))');fprintf(' b(k) b-a\n');% 显示表头fprintf('%2d%36.6f%12.6f%12.6f%12.6f\n',0,a,fa,b,b-a);% 占2位其中0位小数显示步数0, 共12位其中小数6位显示各值3 % while n≤ N4 % 取区间中点p5 % 求p点函数值给变量fpfprintf('%2d%12.6f%12.6f',n,p,fp); % 输出迭代过程中的中点信息p和f(p)6 % 如果f(p)=0或b-a的一半小于误差限εfprintf('\n\n近似解为:%f\n',p); % 则输出近似根p (7)return; % 并结束程序(7)89 % 计数器加110 % 若f(a)与f(p)同号11 % 则取右半区间为新的求根区间, 即a取作p12 % 保存新区间左端点的函数值13 % 否则14 % 左半区间为新的求根区间, 即b取作p15fprintf('%12.6f%12.6f%12.6f%12.6f\n',a,fa,b,b-a);% 显示新区间端点及左端函数值、区间长度16fprintf('\n\n经过%d次迭代后未达到精度要求.\n',N); % 输出错误信息(行17)《数值计算方法》实验2报告班级： 20xx 级XXXXx 班 学号： 20xx2409xxxx 姓名： XXX 成绩：1. 实验名称实验2 非线性方程的迭代解法(之Aitken-Steffensen 加速法) 2. 实验题目用Aitken-Steffensen 加速法求方程010423=-+x x 在区间[1,2]内的一个实根，取绝对误差限为410-．3. 实验目的熟悉求解非线性方程的Aitken-Steffensen 加速法． 4. 基础理论将方程0)(=x f 改写成等价形式)(x x ϕ=，得到从初值0x 开始的迭代公式)(1k k x x ϕ=+后，基于迭代公式)(1k k x x ϕ=+的Aitken-Steffensen 加速法是通过“迭代-再迭代-加速”完成迭代的，具体过程为kk k k k k k k k k k x y z z y x x y z x y +---===+2)(),(),(21ϕϕ． 5. 实验环境操作系统：Windows xp ； 程序设计语言：Matlab 6. 实验过程为了验证Aitken-Steffensen 加速法可以把一些不收敛的迭代加速成迭代收敛，我们使用将方程组变形为31021x x -=，取迭代函数31021)(x x -=ϕ，并利用宏定义出迭代函数．由于不用保存迭代过程，所以用x0表示初值同时也存放前一步迭代的值，y 和z 是迭代过程中产生的y k 和z k ，x 存放新迭代的结果．算法的伪代码描述：Input ：初值x 0；精度要求（即误差限）ε；迭代函数φ（x ）；最大迭代次数N7. 结果与分析8. 附录：程序清单%*************************************************************%* 程序名：Aitken_Steffensen.m *%* 程序功能：用Aitken-Steffensen加速法求方程. *%*************************************************************clc;clear all;phi=inline('0.5 * sqrt( 10 - x^3)'); % 迭代函数x0=input('初值: x0 = ');epsilon=input('误差限: epsilon=');N=input('最大迭代次数: N=');disp(' n 迭代中间值y(n-1) 再迭代结构z(n-1) 加速后的近似值x(n)');fprintf('%2d%54.6f\n',0,x0);% 占2位整数显示步数0, 为了对齐, 占54位小数6位显示x01 % n是计数器2 % while n<=Ny= 3 ; % 迭代z= 3 ; % 再迭代x= 3 ; % 加速% x0初值及前一步的近似值, y和z是中间变量, x是下一步的近似值fprintf('%2d%18.6f%18.6f%18.6f\n',n,y,z,x);% 显示中间值和迭代近似值6 % 如果与上一步近似解差的绝对值不超过误差限fprintf('\n\n 近似解x≈x(%d)≈%f\n',n,x);% 则输出近似根(7)，可简略为: fprintf('\n\n近似解x=%f',x);return; % 并结束程序(7)8 % 相当于endif9 % 计数器加110 % 新近似值x作为下一次迭代的初值11fprintf('\n 迭代%d次还不满足误差要求.\n\n',N); %输出错误信息(12)《数值计算方法》实验2报告班级： 20xx 级XXXXx 班 学号： 20xx2409xxxx 姓名： XXX 成绩：1. 实验名称实验2 非线性方程的迭代解法（之Newton 下山法） 2. 实验题目用Newton 下山法求方程010423=-+x x 在区间[1,2]内的一个实根，取绝对误差限为410-．3. 实验目的熟悉非线性方程的Newton 下山法． 4. 基础理论Newton 下山法：Newton 下山法公式为)(')(1k k kk k x f x f x x λ-=+，使|)(||)(|1k k x f x f <+，其中10≤<k λ．5. 实验环境操作系统：Windows xp ； 程序设计语言：Matlab 6. 实验过程定义函数f(x)和df(x)，其中df(x)是f(x)的导函数．每步迭代时先取下山因子为1，尝试迭代，判断尝试结果是否满足下山因子，若满足则作为这步的迭代结果；否则将下山因子减半，然后再尝试．为防止当前的x k 是极小值点，附近不会有满足下述条件的其它点，使尝试陷入死循环，同时计算机中能表示出的浮点数也有下界，因此我们设置了最大尝试次数．当超过最大尝试次数时，不再进行下山尝试．由于反复尝试迭代且要判断下山条件，所以f (x 0)和f ‘(x 0)会反复使用，为避免重复计算浪费运行时间，将这两个值分别保存在变量fx0和dfx0．而尝试产生的节点，判断下山条件时要用到它的函数值，若尝试成功，这个点会作为下一步的初值再使用，所以把该点的函数值也保存在变量fx 中．算法的伪代码描述：Input ：初值x 0；精度要求（即误差限）ε；函数及其导函数f （x ）和f’(x)；最大迭代次数N ；K 下山尝试最大次数7. 结果与分析8. 附录：程序清单%************************************************************* %* 程序名：NewtonDownhill.m * %* 程序功能：用Newton下山法求解非线性方程. * %*************************************************************clc;clear all;f=inline('x^3-x-1'); % 函数f(x)df=inline('3*x^2-1'); % 函数f(x)的导函数x0=input('初值: x0 = ');epsilon=input('误差限: epsilon=');N=input('最大迭代次数: N=');K=input('最大下山尝试次数: K=');1 % 迭代次数计数器2 % 存x0点函数值fprintf('\n\n n x(n) f(x(n))\n'); % 显示表头fprintf('%2d%14.6f%14.6f\n',0,x0,fx0); % 2位整数显示0, 共14位小数6位显示x0和fx03 % while n ≤ Ndisp(''); % 换行显示下山尝试过程的表头disp(' 下山因子尝试x(n) 对应f(x(n)) 满足下山条件');disp('');4 % 存x0点导数值, 每次下山尝试不用重新计算if dfx0==0 % 导数为0不能迭代disp(‘无法进行Newton迭代’);return;endlambda=1.0; % 下山因子从1开始尝试k=1; % k下山尝试次数计数器while k<=K % 下山最多尝试K次% 下山公式fx=f(x); % 函数值fprintf('%22.6f%14.6f%14.6f',lambda,x,fx); % 显示尝试结果if (abs(fx)<abs(fx0)) % 判断是否满足下山条件fprintf(' 满足\n');break; % 是, 则退出下山尝试的循环elsefprintf(' 不满足\n');endlambda=lambda/2; % 不是, 则下山因子减半k=k+1; % 计数器加1endif k>Kfprintf('\n 下山条件无法满足, 迭代失败.\n\n');return;endfprintf('%2d%14.6f%14.6f\n',n,x,fx);% 2位整数显示步数n, 共14位小数6位显示下步迭代结果22 % 达到精度要求否fprintf('\n\n 方程的近似解为: x≈%f\n\n',x); % (23)return; % 达到, 则显示结果并结束程序(23) end % (24)% 用x0,fx0存放前一步的近似值和它的函数值, 进行循环迭代25262728fprintf('\n 迭代%d次还不满足误差要求.\n\n',N);《数值计算方法》实验2报告班级： 20xx 级XXXXx 班 学号： 20xx2409xxxx 姓名： XXX 成绩：1. 实验名称实验2 非线性方程的迭代解法（之弦截法） 2. 实验题目用弦截法求方程010423=-+x x 在区间[1,2]内的一个实根，取绝对误差限为410-． 3. 实验目的熟悉非线性方程的弦截法． 4. 基础理论将Newton 迭代法中的导数用差商代替，得到弦截法(或叫正割法)公式)()()(111k k k k k k k x f x f x f x x x x --+---=．5. 实验环境操作系统：Windows xp ； 程序设计语言：Matlab 6. 实验过程不保存迭代过程，所以始终以x 0和x 1分别存放x k -1和x k ，而x 存放新产生的迭代值x k +1，这样，下一次迭代时需要把上一步的x 1（即x k ）赋值于x 0（做新的x k -1）．这些点的函数值会重复用到，在迭代公式中也要用到，上一步的x 1作为下一步的x 0也会再一次用它的函数值，为减少重新计算该点函数值的运行时间，将x 1点的函数值保存在变量fx1中．算法的伪代码描述：Input ：初值x 0，x 1；精度要求（即误差限）ε；函数f （x ）；最大迭代次数N7. 结果与分析8. 附录：程序清单%*************************************************************%* 程序名：SecantMethod.m *%* 程序功能：用弦截法求解非线性方程. *%*************************************************************clc;clear all;f=inline('2*x^3-5*x-1'); % 函数f(x)x0=input('第一初值: x0 = ');x1=input('第二初值: x1 = ');epsilon=input('误差限: epsilon=');N=input('最大迭代次数: N=');fprintf('\n n x(n)\n'); % 显示表头fprintf('%2d%14.6f\n', 0, x0); % 占2位显示步数0, 共14位其中小数6位显示x0 fprintf('%2d%14.6f\n', 1, x1); % 占2位显示步数1, 共14位其中小数6位显示x11 % 存x0点函数值2 % 存x1点函数值3 % 迭代计数器4 % while n ≤ N% 弦截法公式fprintf('%2d%14.6f\n', n, x); % 显示迭代过程6 % 达到精度要求否fprintf('\n\n 方程的近似解为: x≈%f\n\n', x);return; % 达到, 则显示结果并结束程序89 % 原x1做x0为前两步的近似值10 % 现x做x1为一两步的近似值11 % x0点函数值12 % 计算x1点函数值, 为下一次循环13 % 计数器加114fprintf('\n 迭代%d次还不满足误差要求.\n\n',N);《数值计算方法》实验3报告班级： 20xx 级XXXXx 班 学号： 20xx2409xxxx 姓名： XXX 成绩：1. 实验名称实验3 解线性方程组的直接法(之Gauss 消去法) 2. 实验题目用Gauss 消去法求解线性方程组⎪⎪⎪⎭⎫ ⎝⎛=⎪⎪⎪⎭⎫ ⎝⎛⎪⎪⎪⎭⎫ ⎝⎛--000.3000.2000.1643.5072.1000.2623.4712.3000.1000.3000.2001.0321x x x ． 3. 实验目的掌握解线性方程组的Gauss 消去法． 4. 基础理论Gauss 消去法是通过对增广矩阵的初等行变换，将方程组变成上三角方程组，然后通过回代，从后到前依次求出各未知数．Gauss 消去法的第k 步(1≤k≤n -1)消元：若0≠kk a ，则依次将增广矩阵第k 行的kkik a a /-倍加到第i 行（k+1≤i≤n ），将第k 列对角线下的元素都化成0． 5. 实验环境操作系统：Windows xp ； 程序设计语言：Matlab 6. 实验过程7. 结果与分析8. 附录：程序清单班级： 20xx 级XXXXx 班 学号： 20xx2409xxxx 姓名： XXX 成绩：1. 实验名称实验3 解线性方程组的直接法(之Gauss 列主元消去法) 2. 实验题目用Gauss 列主元消去法求解线性方程组⎪⎪⎪⎭⎫ ⎝⎛=⎪⎪⎪⎭⎫ ⎝⎛⎪⎪⎪⎭⎫ ⎝⎛--000.3000.2000.1643.5072.1000.2623.4712.3000.1000.3000.2001.0321x x x ． 3. 实验目的掌握解线性方程组的Gauss 列主元消去法． 4. 基础理论Gauss 列主元消去法也是通过对增广矩阵的初等行变换，将方程组变成上三角方程组，然后通过回代，从后到前依次求出各未知数．Gauss 列主元消去法的第k 步(1≤k≤n -1)消元：先在nk k k kk a a a ,,,,1 +中找绝对值最大的，将它所在的行与第k 行交换，然后将第k 行的kk ik a a /-倍加到第i 行（k+1≤i≤n ），将第k 列对角线下的元素都化成0． 5. 实验环境操作系统：Windows xp ； 程序设计语言：Matlab 6. 实验过程7. 结果与分析8. 附录：程序清单班级： 20xx 级XXXXx 班 学号： 20xx2409xxxx 姓名： XXX 成绩：1. 实验名称实验3 解线性方程组的直接法(之Doolittle 分解) 2. 实验题目对矩阵A 进行Doolittle 分解，其中⎪⎪⎪⎪⎪⎭⎫⎝⎛----=3101141101421126A ．3. 实验目的掌握矩阵的Doolittle 分解． 4. 基础理论矩阵的Doolittle 分解是指将矩阵n n ij a A ⨯=)(可以分解为一个单位下三角矩阵和一个上三角矩阵的乘积．若设⎪⎪⎪⎪⎪⎪⎭⎫⎝⎛=⎪⎪⎪⎪⎪⎪⎭⎫⎝⎛=nn n n n n n n u u u u u u u u u u U l l ll l l L000000,1010010001333223221131211321323121则可依如下顺序公式计算⎪⎪⎩⎪⎪⎨⎧++=-=+=-=∑∑-=-=1111,,2,1,/)(,,1,,k t kk tk it ik ik k r rj kr kj kj nk k i u u l a l nk k j u l a u其中k = 1，2，…，n ．5. 实验环境操作系统：Windows xp ； 程序设计语言：Matlab 6. 实验过程（1）按计算公式依次计算一行u 同时计算一列l ；（2）因为计算完u ij （或l ij ）后，a ij 就不再使用，为节省存储空间，将计算的u ij （和l ij ）仍存放在矩阵A 中的相应位置；（3）使用L 矩阵和U 矩阵时需要根据元素所在位置取固定值或A 中相应位置的值．L 对角线上的元素为1，上三角部分为0，下三角部分为A 中对应的元素；U 的下三角部分为0，上三角部分为A 中对应的元素．算法的伪代码描述：Input：阶数n；矩阵A7. 结果与分析8. 附录：程序清单%****************************************************% 程序名: Doolittle.m *% 程序功能: 矩阵LU分解中的Doolittle分解. *%****************************************************clc;clear all;n=4; % 矩阵阶数A=[6 2 1 -1;2 4 1 0; 1 1 4 -1; -1 0 -1 3]disp('A=');disp(A);% LU分解(Doolittle分解)for k=1:n% 计算矩阵U的元素u_{kj}% (可参照下面l_{ik}的公式填写)% 计算矩阵L的元素l_{ik}% L在A下三角, U在上三角(对角线为1) enddisp('分解结果：');disp('L=');for i=1:nfor j=1:nif i>j % 在下三角部分, 则取A对于的元素显示fprintf(' %8.4f',A(i,j));elseif i==j % 在对角线上, 则显示1fprintf(' %8d',1);else % 在上三角部分, 则显示0fprintf(' %8d',0);endendfprintf('\n'); % 换行enddisp('U=');for i=1:nfor j=1:nif i<=j % 在上三角部分或对角线上, 则取A对于的元素显示fprintf(' %8.4f',A(i,j));else % 在下三角部分, 则显示0fprintf(' %8d',0);endendfprintf('\n'); % 换行end《数值计算方法》实验3报告班级： 20xx 级XXXXx 班 学号： 20xx2409xxxx 姓名： XXX 成绩：1. 实验名称实验3 解线性方程组的直接法(之LU 分解法) 2. 实验题目用LU 分解(Doolittle 分解)法求解线性方程组⎪⎩⎪⎨⎧=++=++=++104615631552162321321321x x x x x x x x x 3. 实验目的熟悉解线性方程组LU 分解法． 4. 基础理论若将矩阵A 进行了Doolittle 分解，A = LU ，则解方程组b x A=可以分解求解两个三角方程组b y L =和y x U=．它们都可直接代入求解，其中b y L =的代入公式为∑-==-=11,,2,1,k j j kj k k n k y l b y而y x U=的代入公式为∑+=-=-=nk j kk j kjk k n n k u x uy x 11,,1,,/)( ．5. 实验环境操作系统：Windows xp ； 程序设计语言：Matlab 6. 实验过程（1）Doolittle 分解过程依次计算一行u 同时计算一列l 完成，并将计算的u ij （和l ij ）仍存放在矩阵A 中的相应位置；（2）求解方程组的代入公式中用到的u ij 和l ij 都直接在A 的相应位置取值即可． 算法的伪代码描述：Input ：阶数n ；矩阵A ；常数项向量b5 for k ← 1 to n6 ∑+=-=-=nkjkkjkjk knnkuxuyx11,,1,,/)( 回代求解Ux=y7 endfor8 return x1,…,x n7. 结果与分析8. 附录：程序清单%****************************************************% 程序名: LinearSystemByLU.m *% 程序功能: 利用LU分解(Doolittle分解)解方程组. *%****************************************************clc;clear all;n=3; % 矩阵阶数A=[1 2 6; 2 5 15; 6 15 46];b=[1;3;10];% LU分解(Doolittle分解)for k=1:n% 计算矩阵U的元素u_{kj}% (可参照下面l_{ik}的公式填写)% 计算矩阵L的元素l_{ik}% L在A下三角, U在上三角(对角线为1)endfor k=1:n % 用代入法求解下三角方程组Ly=by(k)=b(k);3%∑-==-=11,,2,1,k j j kjk k n k y lb y3 3enddisp('方程组Ly=b 的解：y='); disp(y');for k=n:-1:1 % 回代求解上三角方程组Ux=y x(k)=y(k);6%∑+=-=-=nk j j kjk k n n k x uy x 11,,1,,66 6enddisp('原方程组的解：x='); disp(x');《数值计算方法》实验3报告班级： 20xx 级XXXXx 班 学号： 20xx2409xxxx 姓名： XXX 成绩：1. 实验名称实验3 解线性方程组的直接法(之Cholesky 分解) 2. 实验题目对矩阵A 进行Cholesky 分解，其中⎪⎪⎪⎪⎪⎭⎫⎝⎛----=3101141101421126A ．3. 实验目的理解矩阵的Cholesky 分解． 4. 基础理论矩阵的Cholesky 分解是指将矩阵n n ij a A ⨯=)(可以分解为一个下三角矩阵L 和L 转置的乘积，即A =LL T ，其中L 各元素可依如下顺序公式计算⎪⎪⎩⎪⎪⎨⎧++=-=-=∑∑-=-=11112,,2,1,/)(k t kktk it ik ik k r kr kk kk nk k i l l l a l l a l其中k = 1，2，…，n ．5. 实验环境操作系统：Windows xp ； 程序设计语言：VC++ 6. 实验过程（1）按计算公式依次先计算一列对角线上的元素l kk ，再计算这列其他元素l ik ，且对称位置的元素也取同一个值；（2）因为计算完l ij 后，a ij 就不再使用，为节省存储空间，将计算的l ij 仍存放在矩阵A 中的相应位置；（3）使用L 矩阵时需要根据元素所在位置取固定值或A 中相应位置的值．L 上三角部分为0，对角线和下三角部分为A 中对应的元素．算法的伪代码描述： Input ：阶数n ；矩阵AOutput ：矩阵L (合并存储在数组A 中)2∑-=-=112k r kr kk kk l a l3 for i ← k to n4 ∑-=-=11/)(k t kk tk it ik ik l l l a l计算结果存放在a ij 5 endfor 6 endfor 7return L输出L7. 结果与分析8. 附录：程序清单%************************************************************* %* 程 序 名：Cholesky.m * %* 程序功能：对称正定矩阵的Cholesky 分解. * %*************************************************************n=4; % 矩阵阶数 A=[6,2,1,-1; 2,4,1,0; 1,1,4,-1; -1,0,-1,3];disp('A ='); for i=1:n for j=1:nfprintf('%10.4f',A(i,j)); % 共占14位end fprintf('\n');% 一行结束换行end% Cholesky 分解for k=1:n% 计算对角线上的l _{kk}% 计算其他的l _{ik} % 和l _{ki}end % L在A下三角, L^T在上三角disp('分解结果：');disp('L=');for i=1:nfor j=1:nif i>=j % 在下三角部分或对角线上, 则取A对于的元素显示fprintf('%10.4f',A(i,j));else % 在上三角部分, 则显示0fprintf('%10d',0);endendfprintf('\n'); % 换行end《数值计算方法》实验3报告班级： 20xx 级XXXXx 班 学号： 20xx2409xxxx 姓名： XXX 成绩：1. 实验名称实验3 解线性方程组的直接法(之改进的Cholesky 分解) 2. 实验题目对矩阵A 进行改进的Cholesky 分解，其中⎪⎪⎪⎪⎪⎭⎫⎝⎛----=3101141101421126A ．3. 实验目的理解矩阵改进的Cholesky 分解． 4. 基础理论矩阵的改进的Cholesky 分解是指将矩阵n n ij a A ⨯=)(可以分解为一个单位下三角矩阵L 和对角矩阵D 及L 转置的乘积，即A =LDL T ，其中L 和D 各元素可依如下顺序公式计算⎪⎪⎩⎪⎪⎨⎧++=-=-=∑∑-=-=11112,,2,1,/)(k t k kt it t ik ik k r kr r kk k nk k i d l l d a l l d a d其中k = 1，2，…，n ．5. 实验环境操作系统：Windows xp ； 程序设计语言：VC++ 6. 实验过程（1）按计算公式依次先计算D 的一个元素d k ，再计算L 中这列的元素l ik ，且对称位置的元素也取同一个值；（2）因为计算完d k 和l ij 后，a kk 或a ij 就不再使用，为节省存储空间，将计算的a kk 或l ij仍存放在矩阵A 中的相应位置；（3）使用L 矩阵时需要根据元素所在位置取固定值或A 中相应位置的值．L 对角线和上三角部分为0，下三角部分为A 中对应的元素；D 对角线为A 中对应的元素，其余都是0．算法的伪代码描述： Input ：阶数n ；矩阵AOutput ：矩阵L (合并存储在数组A 中)2 ∑-=-=112k r kr r kk k l d a d3 for i ← k to n4 ∑-=-=11/)(k t k kt it t ik ik d l l d a l计算结果存放在a ij 5 endfor 6 endfor7return L, D输出L 和D7. 结果与分析8. 附录：程序清单%************************************************************* %* 程 序 名：ImprovedCholesky.m * %* 程序功能：对称正定矩阵的改进的Cholesky 分解. * %*************************************************************n=4; % 矩阵阶数 A=[6,2,1,-1; 2,4,1,0; 1,1,4,-1; -1,0,-1,3];disp('A ='); for i=1:n for j=1:nfprintf('%10.4f',A(i,j)); % 共占14位end fprintf('\n');% 一行结束换行end% Cholesky 分解 for k=1:n% 计算D 对角线上的u _{kk}% 计算L 的元素l _{ik} % 和L 转置的元素l _{ki}end % L在A下三角, D在对角线disp('分解结果：');disp('L=');for i=1:nfor j=1:nif i>j % 在下三角部分, 则取A对于的元素显示fprintf('%10.4f',A(i,j));elseif i==j % 在对角线上, 则显示1fprintf('%10d',1);else % 在上三角部分, 则显示0fprintf('%10d',0);endendfprintf('\n'); % 换行enddisp('D=');for i=1:nfor j=1:nif i==j % 在对角线上, 则取A对于的元素显示fprintf('%10.4f',A(i,j));else % 其余显示0fprintf('%10d',0);endendfprintf('\n'); % 换行end《数值计算方法》实验3报告班级： 20xx 级XXXXx 班 学号： 20xx2409xxxx 姓名： XXX 成绩：1. 实验名称实验3 解线性方程组的直接法(之追赶法) 2. 实验题目用追赶法求解线性方程组⎪⎪⎪⎪⎪⎭⎫ ⎝⎛=⎪⎪⎪⎪⎪⎭⎫ ⎝⎛⎪⎪⎪⎪⎪⎭⎫ ⎝⎛-----101053001210023100124321x x x x 3. 实验目的熟悉解线性方程组的追赶法． 4. 基础理论对于系数矩阵为三对角矩阵的方程组，其Crout 分解可分解为⎪⎪⎪⎪⎪⎪⎭⎫⎝⎛⎪⎪⎪⎪⎪⎪⎭⎫⎝⎛=⎪⎪⎪⎪⎪⎪⎭⎫⎝⎛=------11111211122111122211n n nn n n n n n n t t t s a s a s a s b a c b a c b a c b A这样，解方程组可以由如下2步完成：“追”：,,,3,2,/)(,,/,/,1111111111n i s y a f y t a b s s c t s f y b s i i i i i i i i i i i i =-=-====-----其中：Tn f f ),,(1 为方程组的常数项，n t 没用；“赶”：.1,,2,1,,1 --=-==+n n i x t y x y x i i i i n n5. 实验环境操作系统：Windows xp ； 程序设计语言：Matlab 6. 实验过程在“追”的过程中，向量s 和y 都有n 个元素，t 只有n -1个元素，又1s 和1y 的计算公式与其它i s 和i y 不同，所以先单独计算1s 和1y ，然后在一个n -1次循环中，求其它i s 和i y 以及i t ．由于在“追”的过程中，i b ，i c 和i f 在分别计算完对应的i s ，i t 和i y 后就不再使用，所以借用数组b ，c 和f 存储向量s ，t 和y ；同样在“赶”的过程中，i y 在计算完对应的i x 后就不再使用，所以再一次借用数组f 存储向量x ．追赶法算法的伪代码描述：Input ：阶数n ；三对角矩阵的三条对角线向量a ，b ，c ，常数项向量f Output ：方程组的解x改进的追赶法算法的伪代码描述：Input ：阶数n ；三对角矩阵的三条对角线向量a ，b ，c ，常数项向量f Output ：方程组的解x7. 结果与分析8. 附录：程序清单%*************************************************************%* 程序名：ChaseAfter.m *%* 程序功能：用追赶法求解三对角线性方程组. *%*************************************************************clc;clear all;n=4;a=[0,-1,-1,-3];b=[2, 3, 2, 5];c=[-1, -2, -1, 0];f=[0, 1, 0, 1];% "追"s(1) = b(1);y(1) = f(1); % 先单独求s_1和y_1for k = 1 : n-1% 再求t_i(i=1,2,…,n-1)% s_i(i=2,3,…,n)% y_i(i=2,3,…,n)end% "赶"x(n) = y(n); % 先单独求x_nfor k = n-1 : -1 : 1% 再求x_i(i=n-1,n-2, (1)endx=x' % 输出解向量------------------------------------------------------------------------------------------------------------------- 改进的程序:%*************************************************************%* 程序名：ChaseAfter.m *%* 程序功能：用追赶法求解三对角线性方程组. *%*************************************************************clc;clear all;n=4;a=[0,-1,-1,-3];b=[2, 3, 2, 5];c=[-1, -2, -1, 0];f=[0, 1, 0, 1];% "追"% b(1)=b(1); % s_1仍在b_1中，不用重新计算y(1)=f(1)/b(1); % 先单独y_1for k=1:n-1% 再求t_i(i=1,2,…,n-1)% s_i(i=2,3,…,n)% y_i(i=2,3,…,n)end% "赶"% f(n)=f(n); % x_n等于y_n仍在f_n中for k=n-1:-1:1% 再求x_i(i=n-1,n-2, (1)endx=f' % 输出解向量班级： 20xx 级XXXXx 班 学号： 20xx2409xxxx 姓名： XXX 成绩：1. 实验名称实验4 解线性方程组的迭代法(之Jacobi 迭代) 2. 实验题目用Jacobi 迭代法求解线性方程组1231231232251223x x x x x x x x x +-=⎧⎪++=⎪⎨++=⎪⎪⎩任取3. 实验目的掌握解线性方程组的Jacobi 迭代法． 4. 基础理论将第i （n i ≤≤1）个方程i n in i i b x a x a x a =+++ 2211移项后得到等价方程ii n in i i i i i i i i i a x a x a x a x a b x /)(11,11,11------=++--便可构造出Jacobi 迭代公式,1,0,/)()()(11,)(11,)(11)1(=------=++--+k a x a x a x a x a b x ii k n in k i i i k i i i k i i k i ． 5. 实验环境操作系统：Windows xp ； 程序设计语言：Matlab 6. 实验过程7. 结果与分析8. 附录：程序清单班级： 20xx 级XXXXx 班 学号： 20xx2409xxxx 姓名： XXX 成绩：1. 实验名称实验4 解线性方程组的迭代法(之Gauss-Seidel 迭代) 2. 实验题目用Gauss-Seidel 迭代法求解线性方程组⎪⎪⎩⎪⎪⎨⎧=+-=-+-=+-+-=+-15831110225311621043243214321321x x x x x x x x x x x x x x3. 实验目的掌握解线性方程组的Gauss-Seidel 迭代法． 4. 基础理论将第i （n i ≤≤1）个方程i n in i i b x a x a x a =+++ 2211移项后得到等价方程ii n in i i i i i i i i i a x a x a x a x a b x /)(11,11,11------=++--便可构造出Jacobi 迭代公式,1,0,/)()()(11,)(11,)(11)1(=-----=++--+k a x a x x a x a b x ii k n in k i i i k i i i k i i k i 和Gauss-Seidel 迭代公式,1,0,/)()()(11,)1(11,)1(11)1(=-----=+++--++k a x a x a x x a b x ii k n in k i i i k i i i k i i k i ． 5. 实验环境操作系统：Windows xp ； 程序设计语言：Matlab 6. 实验过程7. 结果与分析8. 附录：程序清单。
秦九韶算法教学过程设计
．
为此 ，引入本课程的主题——秦九韶算法． 秦九韶 （ 公元 １ ２ ０ ８ －１ ２ ６ １年 ），字道古 ，汉族 ，生于普州安岳 （ 今四川省安岳县 ） ．南宋官员 、数 学家 ， 与李冶 、 杨辉和朱世杰并称宋元数学 四大家．他在所著的 《 数书九章》中提出的多项式求值秦九韶 算法至今仍是 比较先进的算法．
７ ４
高 师 理 科 学 刊
第 ３ ７卷
需 要解 决 的 问题 ：给定 Ｘ，计 算 多项 式 Ｐ＝ａ ＋ａ １ ｘ＋… ＋ａ ｘ ” 的值 ．
学生提 出的常用方法是按照项数逐一计算 ，但是逐项生成算法面临 ２ 个主要问题 ： （ １ ） 一旦多项式的次数增加或者多项式 的系数被改变 ，就需要重新计算．能否设计一种算法 ，使其 不依赖于某个具体的多项式． （ ２ ） 逐项生成算法计算量 的大小．如果算法中只出现加减乘除四则运算 ，常用乘除的次数作为算法 的运算量．由于计算 ａ ， ｘ 需要 １ 次乘法 ，计算 ａ ２ ｘ 需要 ２ 次乘法 ，递推可得 ，利用逐项生成算法计算多项
摘 要： 为了实施四川省卓越 中学数学教师教育人才培养计划 ， 针对数学与应用数 学专业 “ 园丁班” 学生特点，紧密结合中学数学，克服学生对算法以及计算机编程的畏难情绪，设计 了秦九韶算法
的教 学过程 ．
关 键 词 ：秦 九韶 算 法 ；教 学设 计 ；ＭＡ Ｔ Ｌ Ａ Ｂ 中 图分 类 号 ：０ ２ ４： Ｇ ６ ４ ２ ． ０ 文献 标识 码 ：Ａ ｄ ｏ ｉ ：１ ０ ． ３ ９ ６ ９ ／ ｊ ． ｉ ｓ ｓ ｎ ． １ ０ ０ ７ — ９ ８ ３ １ ． ２ ０ １ ７ ． ０ １ ． ０ １ ８
秦九韶算法 MATLAB程序
中国地质大学(武汉)数值分析报告
学生姓名：张天馨
所在学院：地球物理与空间信息学院学生班级：061125
学生学号：20121002820
任课教师：付丽华
一、目的
1.熟悉Matlab的基本操作过程
2.掌握在数学领域的相关应用
二、内容
求解秦九韶算法的计算复杂度MATLAB程序设计：
>>tic;
p=input('please input p(x)='); x=input('please input x=');
n=length(p);
s(1)=p(1);
for i=1:n-1
s(i+1)=s(i)*x+p(i+1);
end
p=s(n)
toc;
程序运行结果：
三、实习总结与心得
秦九韶的算法很简单，因此在写这个程序时也并不感到十分困难。
通过这个作业我也更深刻的体会到了用计算机来解决数学问题的便携。
希望能在未来的数值分析学习中充分结合程序技能、融会贯通，用高科技去探索数学世界的奥秘。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
文章标题：深入探讨秦九韶算法的Matlab程序写法
在数学领域中，秦九韶算法是一个非常重要的算法，主要用于多项式
的快速计算和求值。
它由我国古代数学家秦九韶所发明，是一种十分
高效的多项式求值方法。
在本文中，我们将深入探讨秦九韶算法的Matlab程序写法，通过具体的代码示例和讲解，帮助读者更好地理解和掌握这一算法。
1. 算法原理
让我们简要回顾一下秦九韶算法的原理。
该算法的核心思想是通过不
断的迭代和累乘来求解多项式的值，从而实现快速计算。
其数学原理
是利用了多项式的因式分解性质，通过减少乘法次数来提高计算效率。
2. Matlab程序实现
接下来，我们将展示秦九韶算法在Matlab中的具体实现方法。
我们
需要定义一个多项式的系数向量，假设为coeffs，其中 coeffs(i) 表示多项式中 x 的 i 次幂的系数。
我们可以使用如下的Matlab代码来实现秦九韶算法：
```matlab
function result = qinjiushao(coeffs, x)
n = length(coeffs);
b = coeffs(n);
for i = n-1:-1:1
b = coeffs(i) + x * b;
end
result = b;
```
在这段代码中，我们定义了一个名为 qinjiushao 的函数，该函数接受多项式系数向量 coeffs 和自变量 x 作为输入，然后利用秦九韶算法来计算多项式在给定自变量下的值，并将结果保存在 result 中。
通过从高次幂到低次幂的顺序累乘和累加，最终得到多项式的求值结果。
3. 代码解释
让我们逐行解释一下这段代码的实现细节。
我们获取系数向量的长度n，并将最高次幂的系数赋给变量 b。
我们使用 for 循环从 n-1 次幂开始逐次迭代，每次将之前的结果乘以 x 并加上新的系数值。
我们将得到多项式在给定自变量下的值，并将其保存在 result 中返回。
4. 个人观点
对于秦九韶算法的Matlab程序写法，我认为需要注意的是在实现过程中要遵循算法的核心原理，即通过迭代和累乘来求解多项式的值。
在实际应用中，我们还可以根据具体的问题场景对算法进行优化，提高计算效率和准确性。
总结回顾：通过本文的讲解，我们深入探讨了秦九韶算法的Matlab
程序写法，并通过具体代码示例进行了详细解释。
通过对这一算法的
深入理解和实际应用，读者可以更好地掌握秦九韶算法的原理和实现
方法，为解决实际问题提供了有力的工具。
在本文中，我们从算法原理、Matlab程序实现、代码解释和个人观点等多个方面进行了全面的评估和讨论，希望能为读者提供有价值的参
考和帮助。
我也希望读者可以通过自己的实践和思考，进一步深化对
秦九韶算法的理解和运用，为数学领域的研究和应用做出更大的贡献。
在此，我们共享了对秦九韶算法的Matlab程序写法的全面探讨和个
人观点，希望能够对您有所帮助。
感谢阅读！在深入探讨秦九韶算法
的Matlab程序写法后，让我们进一步探讨该算法在实际问题中的应
用和优化方法。
秦九韶算法作为一种高效的多项式求值方法，可以在
求解多项式插值、数值逼近、信号处理等领域发挥重要作用。
我们可以考虑将秦九韶算法应用于多项式插值和数值逼近问题中。
在
实际问题中，我们经常需要通过已知数据点来求解多项式的系数，并
用于对其他未知数据点进行插值或逼近。
通过使用秦九韶算法，我们
可以高效地计算多项式在给定自变量下的值，从而快速完成插值和逼
近的过程。
假设我们需要对一组实验数据进行多项式插值，我们可以利用秦九韶
算法来计算多项式在给定自变量下的值，快速得到插值多项式的系数，并用于对其他数据点的预测。
对于信号处理领域，秦九韶算法也具有重要的应用意义。
在数字信号
处理中，我们经常需要对信号进行多项式拟合或滤波处理。
通过将秦
九韶算法应用于多项式拟合，我们可以快速地计算出拟合多项式的值，从而实现对信号的准确处理和分析。
对于大规模的数据处理和实时应用，我们还可以考虑对秦九韶算法进
行优化。
可以通过并行计算、GPU加速或向量化操作来提高算法的计
算效率，从而更好地满足实际问题的需求。
在优化算法时，我们还需要关注算法的稳定性和准确性。
在实际应用中，我们需要对算法的边界条件、数值稳定性和误差分析进行充分考虑，以确保算法在各种情况下都能够给出准确的结果。
秦九韶算法作为一种高效的多项式求值方法，在数学领域和工程实践
中都具有重要的应用价值。
通过深入理解算法的原理和实现方法，我
们可以更好地利用秦九韶算法解决实际问题，并通过对算法的优化和
改进，进一步提高算法的计算效率和准确性，为实际问题的解决提供
更好的工具和方法。
希望通过本文的深入探讨，读者可以更好地理解和应用秦九韶算法，并在实际问题中发挥其重要作用。
也欢迎读者在实践中不断探索和改进算法，为数学领域和工程实践的发展贡献自己的力量。
谢谢阅读！。