sor算法的程序性能

❶ 如何用MATLAB编写的拉格朗日插值算法的程序、二阶龙格-库塔方法的程序和SOR迭代法的程序

拉格朗日function y=lagrange(x0,y0,x)
n=length(x0);m=length(x);
for i=1:m
z=x(i);
s=0.0;
for k=1:n
p=1.0;
for j=1:n
if j~=k
p=p*(z-x0(j))/(x0(k)-x0(j));
end
end
s=p*y0(k)+s;
end
y(i)=s;
end SOR迭代法的Matlab程序

function [x]=SOR_iterative(A,b)
% 用SOR迭代求解线性方程组,矩阵A是方阵
x0=zeros(1,length(b)); % 赋初值
tol=10^(-2); % 给定误差界
N=1000; % 给定最大迭代次数
[n,n]=size(A); % 确定矩阵A的阶
w=1; % 给定松弛因子
k=1;
% 迭代过程
while k<=N
x(1)=(b(1)-A(1,2:n)*x0(2:n)')/A(1,1);
for i=2:n
x(i)=(1-w)*x0(i)+w*(b(i)-A(i,1:i-1)*x(1:i-1)'-A(i,i+1:n)*x0(i+1:n)')/A(i,i);
end
if max(abs(x-x0))<=tol
fid = fopen('SOR_iter_result.txt', 'wt');
fprintf(fid,'\n********用SOR迭代求解线性方程组的输出结果********\n\n');
fprintf(fid,'迭代次数: %d次\n\n',k);
fprintf(fid,'x的值\n\n');
fprintf(fid, '%12.8f \n', x);
break;
end
k=k+1;
x0=x;
end
if k==N+1
fid = fopen('SOR_iter_result.txt', 'wt');
fprintf(fid,'\n********用SOR迭代求解线性方程组的输出结果********\n\n');
fprintf(fid,'迭代次数: %d次\n\n',k);
fprintf(fid,'超过最大迭代次数，求解失败！');
fclose(fid);
end Matlab中龙格-库塔(Runge-Kutta)方法原理及实现龙格-库塔(Runge-Kutta)方法是一种在工程上应用广泛的高精度单步算法。由于此算法精度高，采取措施对误差进行抑制，所以其实现原理也较复杂。该算法是构建在数学支持的基础之上的。龙格库塔方法的理论基础来源于泰勒公式和使用斜率近似表达微分，它在积分区间多预计算出几个点的斜率，然后进行加权平均，用做下一点的依据，从而构造出了精度更高的数值积分计算方法。如果预先求两个点的斜率就是二阶龙格库塔法，如果预先取四个点就是四阶龙格库塔法。一阶常微分方程可以写作：y'=f(x,y),使用差分概念。
(Yn+1-Yn)/h= f(Xn,Yn)推出（近似等于，极限为Yn'）
Yn+1=Yn+h*f(Xn,Yn)
另外根据微分中值定理，存在0<t<1,使得
Yn+1=Yn+h*f(Xn+th,Y(Xn+th))
这里K＝f(Xn+th,Y(Xn+th))称为平均斜率，龙格库塔方法就是求得K的一种算法。
利用这样的原理，经过复杂的数学推导（过于繁琐省略），可以得出截断误差为O(h^5)的四阶龙格库塔公式：
K1＝f(Xn,Yn);
K2=f(Xn+h/2,Yn+(h/2)*K1);
K3=f(Xn+h/2,Yn+(h/2)*K2);
K4=f(Xn+h,Yn+h*K3);
Yn+1=Yn+h*(K1+2K2+2K3+K4)*(1/6);
所以，为了更好更准确地把握时间关系，应自己在理解龙格库塔原理的基础上，编写定步长的龙格库塔函数，经过学习其原理，已经完成了一维的龙格库塔函数。
仔细思考之后，发现其实如果是需要解多个微分方程组，可以想象成多个微分方程并行进行求解，时间，步长都是共同的，首先把预定的初始值给每个微分方程的第一步，然后每走一步，对多个微分方程共同求解。想通之后发现，整个过程其实很直观，只是不停的逼近计算罢了。编写的定步长的龙格库塔计算函数：
function [x,y]=runge_kutta1(ufunc,y0,h,a,b)%参数表顺序依次是微分方程组的函数名称，初始值向量，步长，时间起点，时间终点（参数形式参考了ode45函数）
n=floor((b-a)/h);%求步数
x(1)=a;%时间起点
y(:,1)=y0;%赋初值，可以是向量，但是要注意维数
for ii=1:n

x(ii+1)=x(ii)+h;

k1=ufunc(x(ii),y(:,ii));

k2=ufunc(x(ii)+h/2,y(:,ii)+h*k1/2);

k3=ufunc(x(ii)+h/2,y(:,ii)+h*k2/2);

k4=ufunc(x(ii)+h,y(:,ii)+h*k3);

y(:,ii+1)=y(:,ii)+h*(k1+2*k2+2*k3+k4)/6;
%按照龙格库塔方法进行数值求解
end
调用的子函数以及其调用语句：
function dy=test_fun(x,y)
dy = zeros(3,1);%初始化列向量
dy(1) = y(2) * y(3);
dy(2) = -y(1) + y(3);
dy(3) = -0.51 * y(1) * y(2);
对该微分方程组用ode45和自编的龙格库塔函数进行比较，调用如下：
[T,F] = ode45(@test_fun,[0 15],[1 1 3]);
subplot(121)
plot(T,F)%Matlab自带的ode45函数效果
title('ode45函数效果')
[T1,F1]=runge_kutta1(@test_fun,[1 1 3],0.25,0,15);%测试时改变test_fun的函数维数，别忘记改变初始值的维数
subplot(122)
plot(T1,F1)%自编的龙格库塔函数效果
title('自编的 龙格库塔函数')

❷ sor迭代算法的matlab程序

function [x k]=EqtsSOR(A,b,x0,omiga,eps)
%超松弛（SOR,Successive Over-Relaxation）迭代法求解线性方程组Ax=b
%[x k]=EqtsSOR(A,b,x0,eps)
%x:解向量，列向量
%k:迭代次数
%A:系数矩阵
%b:列向量
%x0:迭代初始值，列向量
%omiga:松弛因子，可缺省，缺省值为1，即为GS迭代法
%eps:误差限，可缺省，缺省值为0.5e-6
%
%应用举例:
%A=[4 3 0;3 4 -1;0 -1 4];b=[24;30;-24];x0=[1;1;1];omiga=1.25;
%[x k]=EqtsSOR(A,b,x0,omiga,0.5e-6)
%x=EqtsSOR(A,b,x0)

if nargin==4
eps=0.5e-6;
end
if nargin==3
omiga=1;
eps=0.5e-6;
end

%检查输入参数
n=length(b);
if size(A,1) ~= n || n ~= length(x0)
disp('输入参数有误！');
x=' ';
k=' ';
return;
end

%迭代求解
k=0;
x=zeros(n,1);
while 1
k=k+1;
for i=1:n
z=0;
for j=1:i-1
z=z+A(i,j)*x(j);
end
for j=i+1:n
z=z+A(i,j)*x0(j);
end
x(i)=(1-omiga)*x0(i)+omiga*(b(i)-z)/A(i,i);
end
if norm(x-x0)<=eps || k==30
break;
end
x0=x;
end

if k==30
disp('迭代次数太多！')
x=' ';
end

return;

❸ 请c/c++高手看一下关于sor程序的问题

错误不在sor，在这里：
for(j=0;j<m;j++)
{
for(l=0;l<n;l++)
{
a[j][l]=rand();
b[j][l]=rand();
c[j][l]=rand();
d[j][l]=rand();
e[j][l]=rand();
f[j][l]=rand();
u[j][l]=0.0;
}
}
怀疑你的dmatrix函数写的有问题，代码写得很乱，不知道在干什么。估计是内存分配有问题。我这里的运行时错误是访问了非法地址0。环境是VS 2005.

我把你的程序稍微修改了一下，可以看得比较清楚错误的地方。
#include <stdlib.h>
#include <stdio.h>
//#include "nrutil.h"
#include <time.h>
#include <math.h>
#include <stddef.h>

#define MAXITS 1000
#define NR_END 1
#define FREE_ARG char*
#define EPS 1.0e-5

void nrerror(char error_text[]);

void sor(double **a,double **b,double **c,double **d,double **e,double **f,double **u,int jmax,double rjac)
{
int ipass,j,jsw,l,lsw,n;
double anorm,anormf=0.0,omega=1.0,resid;

printf("enter sor\n");

for(j=2;j<jmax;j++)
for(l=2;l<jmax;l++)
anormf+=fabs(f[j][l]);
for(n=1;n<=MAXITS;n++)
{
anorm=0.0;
jsw=1;
for(ipass=1;ipass<=2;ipass++)
{
lsw=jsw;
for(j=2;j<jmax;j++)
{
for(l=lsw+1;l<jmax;l+=2)
{
resid=a[j][l]*u[j+1][l]+b[j][l]*u[j-1][l]+c[j][l]*u[j][l+1]+d[j][l]*u[j][l-1]+e[j][l]*u[j][l]-f[j][l];
anorm+=fabs(resid);
u[j][l]-=omega*resid/e[j][l];
}
lsw=3-lsw;
}
jsw=3-jsw;
omega=(n==1&&ipass==1?1.0/(1.0-0.5*rjac*rjac):1.0/(1.0-0.25*rjac*rjac*omega));
}
if(anorm<EPS*anormf)
return;
}
nrerror("MAXITS exceeded");

}

void nrerror(char error_text[])
{
fprintf(stderr,"Numerical Recipes run-time error...\n");
fprintf(stderr,"%s\n",error_text);
fprintf(stderr,"...now exiting to system...\n");
exit(1);
}
double **dmatrix(long nrl, long nrh, long ncl, long nch)
{
long i, nrow=nrh-nrl+1,ncol=nch-ncl+1;
double **m;

m=(double **) malloc((size_t)((nrow+NR_END)*sizeof(double*)));
if (!m) nrerror("allocation failure 1 in matrix()");
m += NR_END;
m -= nrl;
m[nrl]=(double *) malloc((size_t)((nrow*ncol+NR_END)*sizeof(double)));
if (!m[nrl]) nrerror("allocation failure 2 in matrix()");
m[nrl] += NR_END;
m[nrl] -= ncl;
for(i=nrl+1;i<=nrh;i++) m[i]=m[i-1]+ncol;
printf("dmatrix succeeded!\n");
return m;
}
main()
{

double **a,**b,**c,**d,**e,**f,**u,rjac;
int j,l,jmax;
double pi=3.1415926;
long m=10,n=10;
a=dmatrix(1,m,1,n);
b=dmatrix(1,m,1,n);
c=dmatrix(1,m,1,n);
d=dmatrix(1,m,1,n);
e=dmatrix(1,m,1,n);
f=dmatrix(1,m,1,n);
u=dmatrix(1,m,1,n);
printf("%x, %x, %x, %x, %x, %x, %x\n", (int)a, (int)b, (int)c, (int)d, (int)e, (int)f, (int)u);
scanf("%d",&jmax);
rjac=cos(pi/jmax);
srand((unsigned)time(NULL));
printf("init begin...\n");
for(j=0;j<m;j++)
{
for(l=0;l<n;l++)
{
a[j][l]=rand();
b[j][l]=rand();
c[j][l]=rand();
d[j][l]=rand();
e[j][l]=rand();
f[j][l]=rand();
u[j][l]=0.0;
}
}
printf("init finished!\n");
sor(a,b,c,d,e,f,u,jmax,rjac);
for(j=0;j<10;j++)
{
for(l=0;l<10;l++)
{
printf("%f\t",u[j][l]);
}
printf("\n");
}

getch();
}

❹ SOR迭代法 求MATLAB程序

迭代法 matlab实现代码如下

function [x,n] = jacobi(A,b,x0,eps,varargin)

if nargin ==3

eps = 1.0e-6;

M = 200;

elseif nargin<3

disp('输入参数数目不足3个');

return

elseif nargin ==5

M = varargin{1};

end

D = diag(diag(A)); %%求A的对角矩阵

L = -tril(A,-1); %%求A的下三角矩阵

U = -triu(A,1);%%求A的上三角矩阵

B = D(L+U);

f = D;

x = B*x0+f;

n = 1;%迭代次数

while norm(x-x0)>=eps

x0 = x;

x = B*x0+f

n = n+1;

if(n>=M)

disp('Warning:迭代次数太多,可能不收敛!')

return;

end

end

运行效果如下：

，A对称正定，且0<ω<2，则解Ax=b的SOR方法收敛。

❺ 求助，MATLAB关于sor超松弛算法

function [x,n]=SOR(A,b,x0,w,eps,M)
if nargin==4
eps= 1.0e-6;
M = 200;
elseif nargin<4
error
return
elseif nargin ==5
M = 200;
end

if(w<=0 || w>=2)
error;
return;
end

D=diag(diag(A)); %求A的对角矩阵
L=-tril(A,-1); %求A的下三角阵
U=-triu(A,1); %求A的上三角阵
B=inv(D-L*w)*((1-w)*D+w*U);
f=w*inv((D-L*w))*b;
x=B*x0+f;
n=1; %迭代次数

while norm(x-x0)>=eps
x0=x;
x =B*x0+f;
n=n+1;
if(n>=M)
disp('Warning: 迭代次数太多，可能不收敛！');
return;
end
end
这个程序无误。
w=1时，它们俩是等价的。它们得到的结果如果精度要求低可能一样，但是精度高了后就会不一样的。

❻ sor是谁提出的

D. M. Young于20世纪70年代提出逐次超松弛(Successive Over Relaxation)迭代法，简称SOR方法。

它是为了解决大规模系统的线性等式提出来的，在GS法基础上为提高收敛速度，采用加权平均而得到的新算法。由于超松弛迭代法公式简单，编制程序容易，很多工程学、计算数学中都会应用超松弛迭代方法。使用超松弛迭代法的关键在于选取合适的松弛因子，如果松弛因子选取合适，则会大大缩短计算时间。

SOR方法的思路为：如果能够简单有效地确定单个样本加入样本集后对训练结果的影响，一方面，出现新的样本时可以利用原来的一训练结果而不必重新开始；另一方面，让训练样本逐个进入样本集可以简化寻优过程，提高算法速度。这实际上是将样本集中的样本数减少到一个。

对于逐次超松弛迭代法，松弛因子的选取对算法的收敛速度有很大影响，通常对于方程组Ax=Y，若A为正定矩阵，则当0<w <2时，逐次超松弛迭代恒收敛。

❼ 什么是SOR

SOR是英文Standard Operation Records的缩写，它的中文含意是记录、凭证类文件。

SOR包括了：⑴物料管理记录；⑵生产操作记录；⑶质量检验与管理记录；⑷设备运行与管理记录；⑸卫生操作与管理记录；⑹销售记录；⑺验证报告与验证记录；⑻人员培训与考核记录；⑼文件发放。

SOR 基本解释：

Schele Outlook Report 计划远景报告；sorbose 己酮糖；sale or return 销售或利润；

SOR 网络解释：

1. 逐次超松弛：选主元素消去法的应用四 矩阵的三角分解五 平方根法及改进的平方根法六 追赶法七 列主元三角色解法 2 线性方程组的迭代解法一 雅可比(Jacobi)迭代法二 高斯-塞德尔(Gauss-seidel)迭代法三 逐次超松弛(SOR)迭代法 3 迭代法。

2. 女法师：最佳答案: PET的搭配要看你连的人物而选择用什么,其实在乎的主要就是他的光环,在大多数情况下,一般女法师(sor)会选择噩梦 ACT 2(以后说的都是ACT 2的PET)里的防御型,他的光环可以冻结敌人,降低他们的移动和攻击速度。

3.sor：successive over-relaxation; 超松弛迭代法。

4.sor：subsystem – out – of – service – request; 子系统中断服务请求。

5.sor：sales order; 订单。

6.sor：synchrotron orbital radiation; 同步辐射。

拓展资料：

1.SOR 双语例句Some of t hese food companies are a t t he forefron t of bes t prac t ice in t he food ins t ry - and t hey can't afford t o have t heir brand t ain t ed by con t amina t ion of anysort - including lubrican t s.

这其中的一些公司都处于食品行业执行最佳规范的前沿－因而，它们不希望它们的品牌因为某种形式的污染事件而受到玷污－包括润滑油污染。

2. Compared with the result of theSORmethod, the result of this algorithm shows the algorithm can accelerate converg ence.

比较了该算法和用超松弛法计算的结果，表明采用该算法确实可以加快收敛速度。

3. The numerical results also express that the stability of new algorithm is better than that of theSORmethod of Cottle and Coheen。

数值结果还表明，新算法比Cottle和Coheen的SOR法稳定。

❽ 急需用SOR法求解方程组的程序要求精度为10的-6次方

SOR迭代法的Matlab程序

function [x]=SOR_iterative(A,b)
% 用SOR迭代求解线性方程组,矩阵A是方阵
x0=zeros(1,length(b)); % 赋初值
tol=10^(-2); % 给定误差界
N=1000; % 给定最大迭代次数
[n,n]=size(A); % 确定矩阵A的阶
w=1; % 给定松弛因子
k=1;
% 迭代过程
while k<=N
x(1)=(b(1)-A(1,2:n)*x0(2:n)')/A(1,1);
for i=2:n
x(i)=(1-w)*x0(i)+w*(b(i)-A(i,1:i-1)*x(1:i-1)'-A(i,i+1:n)*x0(i+1:n)')/A(i,i);
end
if max(abs(x-x0))<=tol
fid = fopen('SOR_iter_result.txt', 'wt');
fprintf(fid,'\n********用SOR迭代求解线性方程组的输出结果********\n\n');
fprintf(fid,'迭代次数: %d次\n\n',k);
fprintf(fid,'x的值\n\n');
fprintf(fid, '%12.8f \n', x);
break;
end
k=k+1;
x0=x;
end
if k==N+1
fid = fopen('SOR_iter_result.txt', 'wt');
fprintf(fid,'\n********用SOR迭代求解线性方程组的输出结果********\n\n');
fprintf(fid,'迭代次数: %d次\n\n',k);
fprintf(fid,'超过最大迭代次数，求解失败！');
fclose(fid);
end

❾ SOR迭代 程序

用户信息
您好：金305
试用期 一级 ( 4 )
• 我的提问 • 个人中心
• 我的回答 • 退出

同类热点问题
• 过程,模块,函数,类,他们有什么不同?
• 谁了解字体数据结构？
• 我用CAD2004作图，在打印时为什么有些字体打不出来
• 二叉树(中序，前序，顺序，静态，传地址)
• 不做题得高分（进来看看吧）！
更多>>

您想在自己的网站上展示
网络“知道”上的问答吗？
来获取免费代码吧！
--------------------------------------------------------------------------------
如对“知道”有疑问或建议，请点此与我们联系

订阅该问题

待解决