数值计算C语言常用小程序Word文档格式.docx

数值计算C语言常用小程序Word文档格式.docx

《数值计算C语言常用小程序Word文档格式.docx》由会员分享，可在线阅读，更多相关《数值计算C语言常用小程序Word文档格式.docx（18页珍藏版）》请在冰豆网上搜索。

printf（"

v=%f"

v）;

运行结果：

2、二分法

P11.1用二分法求方程法x*x*x-x-1=0在[1,2]内的近似根，要求误差不超过

floatfun（float）;

{floata,b,c,x,y,y1;

%f%f%f"

a,&

b,&

c）;

y1=fun（a）;

{x=（a+b）/2;

y=fun（x）;

{if（y*y1>

0）

a=x;

else

b=x;

}}

while（（b-a）>

=c）;

%f,%f\n"

x,y）;

floatfun（floatm）

{floatn;

n=m*m*m-m-1;

return（n）;

3、拉格朗日插值

main（）

{floata,b,t,x[100],y[100];

intn,i,j,k;

%f%d"

n）;

%f%f"

x[i],&

y[i]）;

k=0;

b=0;

for（k=0;

k<

k++）

{t=1;

for（j=0;

j<

j++）

{if（j!

=k）

t=t*（a-x[j]）/（x[k]-x[j]）;

b=b+t*y[k];

%f\n"

b）;

4、埃特金算法

{floata,b,c,x[100],y[100];

inti,j,n,k;

a）;

for（k=1;

{for（i=k;

y[i]=y[k-1]+（y[i]-y[k-1]）*（a-x[k-1]）/（x[i]-x[k-1]）;

y[n]）;

5、复化梯形法

P95.9设,用复化梯形法求积分的近似值

doublefun（double）;

{

doublea,b,h,s,x,y;

intn,k;

%lf%lf%d"

h=（b-a）/n;

s=0;

x=a;

{s=s+fun（x）;

x=x+h;

s=s+fun（x）;

s=（h/2）*s;

s=%lf\n"

s）;

doublefun（doublem）

{doublen;

n=exp（-m）*sin（4*m）+1;

6、复化辛甫生算法

P95.9设,用复化辛甫生法求积分的近似值

x=x+h/2;

s=s+4*fun（x）;

s=（h/6）*s;

7、二阶龙格库塔方法

求解初值问题：

取h=0.2

floatfun（float,float）;

{floath,x0,y0,x1,y1,k1,k2;

intn,N;

%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;

x1,y1）;

x0=x1;

y0=y1;

floatfun（floata,floatb）

{floatm;

m=b-2*a/b;

return（m）;

8、四阶龙格库塔方法

{floath,x0,y0,x1,y1,k1,k2,k3,k4;

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）;

%f,%f"

9、改进的欧拉方法

{floatx0,y0,h,x1,y1,yp,yc;

yp=y0+h*fun（x0,y0）;

yc=y0+h*fun（x1,yp）;

y1=（yp+yc）/2;

10、迭代法

P131例2用迭代法求方程在附近的一个根，要求精度为

{floatx0,x1,c;

intk,N;

%f%f%d"

c,&

{x1=fun（x0）;

printf（"

x1）;

if（fabs（x1-x0）<

c）break;

x0=x1;

if（k-1==N）

Failure!

\n"

）;

n=exp（-m）;

11、埃特金加速方法：

{floatx0,x1,x2,c;

x2=fun（x1）;

x2=x2-（x2-x1）*（x2-x1）/（x2-2*x1+x0）;

if（fabs（x2-x0）<

c）

{printf（"

x2）;

break;

x0=x2;

12、牛顿迭代法：

例5、用牛顿法解方程

牛顿公式为：

，取x=0.5

floatff（float）;

{if（ff（x0）!

=0）

{x1=x0-fun（x0）/ff（x0）;

}

****"

if（k==N）

n=m-exp（-m）;

floatff（floatm）

n=1+m;

13、追赶法：

P198.3.用追赶法求解下列方程组：

{floata[100],b[100],c[100],d[100],t;

inti,n;

%d"

for（i=2;

for（i=1;

b[i]）;

=n-1;

c[i]）;

d[i]）;

c[1]=c[1]/b[1];

d[1]=d[1]/b[1];

n;

{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]）;

d[n]）;

for（i=n-1;

i>

=1;

i--）

{d[i]=d[i]-c[i]*d[i+1];

d[i]）;

14、雅克比迭代

#defineN50 

#defineM4

{doublex[M],y[M],a[M][M],b[M],d[M],c,t;

doubleff（double[],int）;

intk,i,j,n;

n=M-1;

%lf"

{scanf（"

x[i]）;

} 

a[0][i*M+j]）;

{for（i=1;

{for（j=1,t=0;

{if（j==i）

continue;

t=t+a[i][j]*x[j];

y[i]=（b[i]-t）/a[i][i];

d[i]=fabs（x[i]-y[i]）;

t=ff（d,n+1）;

if（t<

x[i]=y[i];

if（k<

N）

{printf（"

k=%d\n"

k）;

y[i]=%f\n"

y[i]）;

doubleff（doublea[],intn）

{doublep;

intt;

p=a[1];

for（t=2;

t<

t++）

{if（p<

a[t]）

p=a[t];

return（p）;

15、蛋白质设计：

#include<

stdlib.h>

横坐标 

纵坐标 

竖坐标\n"

FILE*fp;

charc[100],x[3000][7],y[3000][7],z[3000][7];

floata[3000],b[3000],d[3000],r[3000];

inti,k=0,j,n=0,m,p;

floatX[3000],Y[3000],Z[3000],s1=0,s2=0,s3=0,av_x,av_y,av_z;

fp=fopen（"

1a1c.pdb"

"

r"

=10000;

fgets（c,81,fp）;

if（c[0]=='

A'

&

c[1]=='

T'

c[2]=='

O'

c[3]=='

M'

） 

6;

{x[k][j]=c[32+j];

%c"

x[k][j]）;

"

j++） 

{y[k][j]=c[40+j];

y[k][j]）;

{z[k][j]=c[48+j];

z[k][j]）;

X[k]=atof（x[k]）;

s1+=X[k];

Y[k]=atof（y[k]）;

s2+=Y[k];

Z[k]=atof（z[k]）;

s3+=Z[k];

k++;

if（c[77]=='

C'

）n++;

av_x=s1/k;

av_y=s2/k;

av_z=s3/k;

共有:

%d\n"

k+1）;

av_x=%f,av_y=%f,av_z=%f\n"

av_x,av_y,av_z）;

C原子个数为:

n）;

平移原点后的坐标:

for（m=0;

m<

k;

m++）

{a[m]=X[m]-av_x;

%f 

a[m]）;

b[m]=Y[m]-av_y;

b[m]）;

d[m]=Z[m]-av_z;

d[m]）;

r[m]=sqrt（a[m]*a[m]+b[m]*b[m]+d[m]*d[m]）;

r[m]）;

#include"

stdio.h"

#include"

math.h"

{doublea[3][3]={1,1,1,0,4,-1,2,-2,1},b[3]={6,5,1},x[10]={0};

inti,j,k,n=3;

n-1;

{ 

for（i=k+1;

{ 

for（j=k+1;

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];

k=n-i;

for（j=k+1;

x[k]+=a[k][j]*x[j];

x[k]=（b[k]-x[k]）/a[k][k];

x[%d]=%f"

k,x[k]）;