精华内容
下载资源
问答
  • 线性方程组数值解法及R语言实现

    千次阅读 2018-09-18 16:58:29
    线性方程组数值解法及其R语言实现

    LU分解

    对矩阵进行LU分解,可将其分解为一个上三角矩阵和下三角矩阵,这样对于求解线性方程组时可简化许多计算量。
    分解方法
    最终可得 A = L U A=LU A=LU,其中L是一个下三角矩阵,U是一个上三角矩阵。
    此时求解线性方程组 A x = b Ax=b Ax=b变为求解 L U x = b LUx=b LUx=b,若记 U x = y Ux=y Ux=y,则原式即求解 L y = b Ly=b Ly=b,而由于L是下三角矩阵,因此可以轻松地求出y,此时再求解 U x = y Ux=y Ux=y,而由于U是一个上三角矩阵,因此可轻松地求出x。因此步骤如下:

    A=LU
    Ly=b
    Ux=y
    下面是R语言实现
    A <- matrix(c(4,2,3,5,-8,1,4,7,-9),nrow=3,byrow=T)
    b <- matrix(c(1,4,0))
    lusolution <- function(A,b){
      ##LU decompose
      ##Doolittle
      t1 = Sys.time()
      U = A
      n = ncol(A)
      L = diag(n)
      
      for(k in 1:(n-1)){
        for(j in (k+1):n){
          L[j,k] = U[j,k]/U[k,k]
          U[j,k:n] = U[j,k:n] - L[j,k]*U[k,k:n]
        }
      }
      ##solute Ly = b
      y = matrix(rep(0,n))
      y[1] = L[1,1]
      for(i in 2:n){
        s = b[i]
        for(j in 1:(i-1)){
          s = s - L[i,j]*y[j]
        }
        y[i] = s/L[i,i]
      }
      ##solute UX = y
      x = matrix(rep(0,n))
      x[n] = U[n,n]
      for(i in (n-1):1){
        s = y[i]
        for(j in i:(n-1)){
          s = s - U[i,j]*x[j]
        }
        x[i] = s/U[i,i]
      }
      print(Sys.time()-t1)
      return(x)
    }
    lusolution(A,b)
    

    Gauss-Seidel迭代

    设线性方程组为Ax=b,将A拆分为一个对角阵,下三角矩阵L和上三角矩阵U,即A=D-L-U
    在这里插入图片描述
    则方程变为Lx = b-Ux,由此建立迭代公式
    x ( k + 1 ) = ( D − L ) − 1 U x ( k ) + ( D − L ) − 1 b x^{(k+1)}=(D-L)^{-1}Ux^{(k)}+(D-L)^{-1}b x(k+1)=(DL)1Ux(k)+(DL)1b
    若记 B = ( D − L ) − 1 U , f = ( D − L ) − 1 b B=(D-L)^{-1}U,f=(D-L)^{-1}b B=(DL)1U,f=(DL)1b,则原式即 x ( k + 1 ) = B x ( k ) + f x^{(k+1)}=Bx^{(k)}+f x(k+1)=Bx(k)+f
    可以看到要对矩阵(D-L)求逆,因此由此可以得到Gauss-Seidel迭代的收敛条件:

    1. A不可逆
    2. 矩阵B的谱半径小于1,即B矩阵最大特征值小于1

    下面是R语言实现

    A1 = matrix(c(3,1,1,0,1,5,-1,2,1,0,3,1,0,1,1,4),nrow=4,byrow=T)
    A2 = matrix(c(2.5,1,1,0,1,4.1,-1,2,1,0,2.1,1,0,1,1,2.1),nrow=4,byrow=T)
    A3 = matrix(c(2,1,1,0,1,3.5,-1,2,1,0,2.1,1,0,1,1,2.1),nrow=4,byrow=T)
    b1 = matrix(c(1,4,-2,1))
    b2 = b1;b3 = b1
    
    
    gauss.seidel <- function(A,b,x,iter=200,tol=1e-8){
      if(det(A)==0){
        return(c('A can not inverse!'))
      }
      m = nrow(A)
      n = ncol(A)
      D = diag(n)
      L = matrix(0,nrow=m,ncol=n)
      for(i in 1:n){
        D[i,i] = A[i,i]
      }
      for(i in 2:n){
        for(j in 1:(i-1)){
          L[i,j] = -A[i,j]
        }
      }
      U = D-L-A
      B = solve(D-L)%*%U
      f = solve(D-L)%*%b
    
      rho <- max(eigen(B)$values)
      if(rho>=1){
        return(c('Warning:it will not converge!'))
      }
      outstats = as.data.frame(matrix(rep(0,(2+n)*iter),nrow=iter))
      x <- t(as.matrix(outstats[1,3:(n+2)]))
      for(i in 1:iter){
        x0 = B%*%x + f
        outstats[i,] <- matrix(c(i,norm(x-x0)/norm(x0),t(x0)),nrow=1)
        
        if(norm(x-x0) < tol*norm(x0)){
          result <- list('x'=x0,'outstats'=outstats[1:i,],'iter'=i,'rho'=rho)
          return(result)
          break
        }
        x <- x0
      }
      result <- list('x'=x,'outstats'=outstats,'iter'=i,'rho'=rho)
      return(result)
    }
    x <- c(0,0,0,0)
    Y1 = gauss.seidel(A1,b1,x)
    print(Y1)
    Y2 = gauss.seidel(A2,b2,x)
    print(Y2)
    gauss.seidel(A3,b3,x)
    

    Jacobi迭代

    设线性方程组为Ax=b,将A矩阵拆分为对角元素与其余元素的差,即A=D-N
    则可写出迭代式
    x ( k + 1 ) = D − 1 N x + D − 1 b x^{(k+1)}=D^{-1}Nx+D^{-1}b x(k+1)=D1Nx+D1b
    M = D − 1 N , f = D − 1 b M=D^{-1}N,f=D^{-1}b M=D1N,f=D1b,则原式即 x ( k + 1 ) = M x ( k ) + f x^{(k+1)}=Mx^{(k)}+f x(k+1)=Mx(k)+f
    由此可写出收敛条件:

    1. A不可逆
    2. M谱半径小于1,即M的最大特征值小于1
      下面是R语言实现
    A1 = matrix(c(3,1,1,0,1,5,-1,2,1,0,3,1,0,1,1,4),nrow=4,byrow=T)
    A2 = matrix(c(2.5,1,1,0,1,4.1,-1,2,1,0,2.1,1,0,1,1,2.1),nrow=4,byrow=T)
    A3 = matrix(c(2,1,1,0,1,3.5,-1,2,1,0,2.1,1,0,1,1,2.1),nrow=4,byrow=T)
    b1 = matrix(c(1,4,-2,1))
    b2 = b1;b3 = b1
    
    jacobi.iter <- function(A,b,iter=1000){
      if(det(A)==0){
        return(c('A can not inverse!'))
      }
      m = nrow(A)
      n = ncol(A)
      D = diag(n)
    
      for(i in 1:n){
        D[i,i] = A[i,i]
      }
      N = D-A
      x = matrix(rep(0,n))
      M = solve(D)%*%N
      f = solve(D)%*%b
      #谱半径>1则发散
      if(max(eigen(M)$values)>=1){
        return(c('Warning:it will not converge!'))
      }
      for(i in 1:iter){
        x0 = M%*%x + f
        if(sum(abs(x0-x))<.00001){
          return(x0)
        }
        x = x0
      }
      return(x)
    }
    
    x1 = jacobi.iter(A1,b3)
    A1%*%x1
    x2 = jacobi.iter(A2,b2)
    A2%*%x2
    jacobi.iter(A3,b3)
    
    展开全文
  • 淮海工学院 计算机工程学院 实验报告 数值分析 线性方程组数值解法
  • 1、熟悉求解线性方程组的有关理论和方法; 2、会编制LU 分解法、雅可比及高斯—塞德尔迭代法德程序; 3、通过实际计算,进一步了解各种方法的优缺点,选择合适的数值方法。 二、算法描述 3.1 矩阵直接三角分解法 ...

    一、实验目的

    1、熟悉求解线性方程组的有关理论和方法;
    2、会编制LU 分解法、雅可比及高斯—塞德尔迭代法德程序;
    3、通过实际计算,进一步了解各种方法的优缺点,选择合适的数值方法。

    二、算法描述

    3.1 矩阵直接三角分解法
    算法
    将方程组Ax=b 中的A分解为A=LU,其中L为单位下三角矩阵,U为上三角矩阵,则方程组Ax=b化为解2个方程组Ly=b,Ux=y,具体算法如下:
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    3.2 迭代法
    3.2.1 雅可比迭代法
    算法:设方程组Ax=b系数矩阵的对角线元素在这里插入图片描述,M为迭代次数容许的最大值,ε为容许误差。
    在这里插入图片描述
    3.2.2 高斯-塞尔德迭代法
    算法:设方程组Ax=b的系数矩阵的对角线元素,在这里插入图片描述,M为迭代次数容许的最大值,ε为容许误差
    在这里插入图片描述
    在这里插入图片描述

    三、源程序

    1、矩阵直接三角分解法

    #include <iostream>
    #include <math.h>
    #include <iomanip>
    using namespace std;
    
    /*
    1 2 -12 8
    5 4 7 -2
    -3 7 9 5
    6 -12 -8 3
    
    27 4 11 49
    */
    int main()
    {
    	cout << "矩阵直接三角分解法\n\n请输入矩阵阶数:" << endl;
    	int n;
    	cin >> n;
    	//数组a[n+1][n+1];
    	int** a = new int* [n+1];
    	for (int i = 0; i <= n; i++)
    	{
    		a[i] = new int[n+1];
    	}
    	//上三角矩阵
    	double** u = new double* [n + 1];
    	for (int i = 0; i <= n; i++)
    	{
    		u[i] = new double[n + 1];
    	}
    	for (int i = 1; i <= n; i++)
    	{
    		for (int j = 1; j <= n; j++)
    		{
    			u[i][j]=0;
    		}
    	}
    	//单位下三角矩阵
    	double** l = new double* [n + 1];
    	for (int i = 0; i <= n; i++)
    	{
    		l[i] = new double[n + 1];
    	}
    	for (int i = 1; i <= n; i++)
    	{
    		for (int j = 1; j <= n; j++)
    		{
    			if(i==j)l[i][j] = 1;
    			else l[i][j] = 0;
    		}
    	}
    
    	double* b = new double[n+1];
    	double* y = new double[n + 1];
    	double* x = new double[n + 1];
    	
    	
    	cout << "请输入矩阵A的值:" << endl;
    	for (int i = 1; i<=n; i++)
    	{
    		for (int j =1 ; j<=n; j++)
    		{
    			cin >> a[i][j];
    		}
    	}
    	cout << "请输入矩阵b的值:" << endl;
    	for (int i = 1; i<=n; i++)
    	{
    		cin >> b[i];
    	}
    
    	for (int j = 1; j <= n; j++)
    	{
    		u[1][j] = a[1][j];
    	}
    	for (int i = 2; i <= n; i++)
    	{
    		l[i][1] = a[i][1]*1.0 / a[1][1];
    	}
    	for (int k = 1; k <= n; k++)
    	{
    		for (int j = k; j <= n; j++)
    		{
    			u[k][j] = a[k][j];
    			for (int q = 1; q <= k - 1; q++)
    			{
    				u[k][j] -= l[k][q] * u[q][j];
    			}
    		}
    		for (int i = k + 1; i <= n; i++)
    		{
    			l[i][k] = a[i][k];
    			for (int q = 1; q <= k - 1; q++)
    			{
    				l[i][k] -= l[i][q] * u[q][k];
    			}
    			l[i][k] = l[i][k]*1.0/u[k][k];
    		}
    	}
    	
    	y[1] = b[1];
    	for (int k = 2; k <= n; k++)
    	{
    		y[k] = b[k];
    		for (int q = 1; q <= k - 1; q++)
    		{
    			y[k] -= l[k][q] * y[q];
    		}
    	}
    	x[n] = y[n]*1.0 / u[n][n];
    	for (int k = n - 1; k >= 1; k--)
    	{
    		x[k] = y[k];
    		for (int q = k + 1; q <= n; q++)
    		{
    			x[k] -= u[k][q] * x[q];
    		}
    		x[k] = x[k] *1.0/u[k][k];
    	}
    	cout << "结果为:" << endl;
    	for (int i = 1; i <= n; i++)
    	{
    		cout << "X[" << i-1 << "]=" << setiosflags(ios::fixed) << setprecision(6) << x[i]<<endl;
    	}
    	return 0;
    }
    

    2、雅可比迭代法

    #include <iostream>
    #include <math.h>
    #include <iomanip>
    using namespace std;
    
    /*
    5 2 1
    2 8 -3
    1 -3 -6
    
    8 21 1
    */
    int main()
    {
    	cout << "雅可比迭代法\n\n请输入矩阵阶数:" << endl;
    	int n,count,e;
    	cin >> n;
    	//数组a[n+1][n+1];
    	int** a = new int* [n + 1];
    	for (int i = 0; i <= n; i++)
    	{
    		a[i] = new int[n + 1];
    	}
    	
    	double* b = new double[n + 1];
    	cout << "请输入矩阵A的值:" << endl;
    	for (int i = 1; i <= n; i++)
    	{
    		for (int j = 1; j <= n; j++)
    		{
    			cin >> a[i][j];
    		}
    	}
    	for (int i = 1; i <= n; i++)
    	{
    		for (int j = 1; j <= n; j++)
    		{
    			if (i == j && a[i][j] == 0)
    			{
    				cout << "对角线元素不能为0,请重新输入!" << endl;
    				return 0;
    			}
    		}
    	}
    	
    	cout << "请输入矩阵b的值:" << endl;
    	for (int i = 1; i <= n; i++)
    	{
    		cin >> b[i];
    	}
    	cout << "请输入迭代次数允许的最大值:" << endl;
    	cin >> count;
    	cout << "请输入容许误差:" << endl;
    	cin >> e;
    
    	double** x = new double* [n + 1];
    	for (int i = 0; i <= n; i++)
    	{
    		x[i] = new double[count+1];
    	}
    	double* x1 = new double[n + 1];//最终结果
    	//设置初始向量
    	for (int i = 1; i <= n; i++)
    	{
    		x[i][0]=0;
    	}	
    	int k,num=0;
    	for (k = 0;;)
    	{
    		int sum = 0;
    		for (int i = 1; i <= n; i++)
    		{
    			x[i][k + 1] = b[i];
    			for (int j = 1; j <= n; j++)
    			{
    				if (j != i)
    				{
    					x[i][k + 1] -= a[i][j] * x[j][k];
    				}
    			}
    			x[i][k + 1] /= a[i][i];
    			x1[i-1] = x[i][k + 1];
    			sum += abs(x[i][k + 1] - x[i][k]);
    		}
    		if (sum >= e)
    		{
    			if (k >= count)
    			{
    				//cout << "超出迭代次数允许的最大值,程序结束";
    				break;
    			}
    			else
    			{
    				k = k + 1;
    			}
    		}
    	}
    	for (int i = 0; i <n; i++)
    	{
    		cout << "X[" << i << "]=" << setiosflags(ios::fixed) << setprecision(6) << x1[i] << endl;
    	}
    	return 0;
    }
    

    3、高斯-赛德尔迭代法

    #include <iostream>
    #include <math.h>
    #include <iomanip>
    using namespace std;
    
    /*
    8 -3 2
    4 11 -1
    6 3 12
    
    20 33 36
    */
    int main()
    {
    	cout << "高斯-赛德尔迭代法\n\n请输入矩阵阶数:" << endl;
    	int n, count, e;
    	cin >> n;
    	//数组a[n+1][n+1];
    	int** a = new int* [n + 1];
    	for (int i = 0; i <= n; i++)
    	{
    		a[i] = new int[n + 1];
    	}
    
    	double* b = new double[n + 1];
    	cout << "请输入矩阵A的值:" << endl;
    	for (int i = 1; i <= n; i++)
    	{
    		for (int j = 1; j <= n; j++)
    		{
    			cin >> a[i][j];
    		}
    	}
    	for (int i = 1; i <= n; i++)
    	{
    		for (int j = 1; j <= n; j++)
    		{
    			if (i == j && a[i][j] == 0)
    			{
    				cout << "对角线元素不能为0,请重新输入!" << endl;
    				return 0;
    			}
    		}
    	}
    
    	cout << "请输入矩阵b的值:" << endl;
    	for (int i = 1; i <= n; i++)
    	{
    		cin >> b[i];
    	}
    	cout << "请输入迭代次数允许的最大值:" << endl;
    	cin >> count;
    	cout << "请输入容许误差:" << endl;
    	cin >> e;
    
    	double** x = new double* [n + 1];
    	for (int i = 0; i <= n; i++)
    	{
    		x[i] = new double[count + 1];
    	}
    	double* x1 = new double[n + 1];//最终结果
    	//设置初始向量
    	for (int i = 1; i <= n; i++)
    	{
    		x[i][0] = 0;
    	}
    	int k;
    	for (k = 0;;)
    	{
    		int sum = 0;
    		for (int i = 1; i <= n; i++)
    		{
    			x[i][k + 1] = b[i];
    			for (int j = 1; j <= i-1; j++)
    			{
    				x[i][k + 1] -= a[i][j] * x[j][k+1];
    			}
    			for (int j = i+1; j <= n; j++)
    			{
    				x[i][k + 1] -= a[i][j] * x[j][k];
    			}
    			x[i][k + 1] /= a[i][i];
    			x1[i - 1] = x[i][k + 1];
    			sum += abs(x[i][k + 1] - x[i][k]);
    		}
    		if (sum >= e)
    		{
    			if (k >= count)
    			{
    				//cout << "超出迭代次数允许的最大值,程序结束";
    				break;
    			}
    			else
    			{
    				k = k + 1;
    			}
    		}
    	}
    	for (int i = 0; i < n; i++)
    	{
    		cout << "X[" << i << "]=" << setiosflags(ios::fixed) << setprecision(6) << x1[i] << endl;
    	}
    	return 0;
    }
    
    展开全文
  • //列主元高斯消去法 /* 2(x1)+4(x2)+(x3)=4 2(x1)+6(x2)-(x3)=10 (x1)+5(x2)+2(x3)=2 */ #include #include void main(){ void ColPivot(float *,int,float[]); int i;... float c[3][4]={

     

    //列主元高斯消去法
    /*  2(x1)+4(x2)+(x3)=4
        2(x1)+6(x2)-(x3)=10
    	(x1)+5(x2)+2(x3)=2
    */
    #include<stdio.h>
    #include<math.h>
    void main(){
    	void ColPivot(float *,int,float[]);
    	int i;
    	float x[3];
    	float c[3][4]={
    		   2,4,1,4,
               2,6,-1,10,
               1,5,2,2};
    	ColPivot(c[0],3,x);
    	for(i=0;i<=2;i++)
       printf("x[%d]=%f\n",i,x[i]);
    }
    void ColPivot(float *c,int n,float x[])
    {
    	int i,j,k,t;
    	float p;
    	for(i=0;i<=n-2;i++)
    	{
    	   k=i;
    	   for(j=i+1;j<=n-1;j++)
    		   if(fabs(*(c+j*(n+1)+i))>(fabs(*(c+k*(n+1)+i))))k=j;
    		   if(k!=i)
    			   for(j=i;j<=n;j++)
    			   {
    				   p=*(c+i*(n+1)+j);
    				   *(c+i*(n+1)+j)=*(c+k*(n+1)+j);
                       *(c+k*(n+1)+j)=p;
    			   }
    			   for(j=i+1;j<=n-1;j++){
    				   p=(*(c+j*(n+1)+i))/(*(c+i*(n+1)+i));
    				   for(t=i;t<=n;t++) *(c+j*(n+1)+t)-=p*(*(c+i*(n+1)+t));
    			   }
    	}
    	for(i=n-1;i>=0;i--){
    	   for(j=n-1;j>=i+1;j--)
    		   (*(c+i*(n+1)+n))-=x[j]*(*(c+i*(n+1)+j));
    	    x[j]=*(c+i*(n+1)+n)/(*(c+i*(n+1)+i));
    	}
    }

    展开全文
  • 线性方程数值解法.ppt
  • 1.向量与矩阵的范数 /* Norms of Vectors and Matrices */ 为了研究线性方程组数值解法的误差估计和迭代法的收敛 性,有必要引进向量范数和矩阵范数的概念。
    1.向量与矩阵的范数 /* Norms of Vectors and Matrices */

    为了研究线性方程组数值解法的误差估计和迭代法的收敛 性,有必要引进向量范数和矩阵范数的概念。

    1. 欧式范数

    设𝒙 =( 𝑥1,𝑥2,…,𝑥𝑛) 𝑇,𝒚 = (𝑦1,𝑦2,…,𝑦𝑛) ∈ ℝ𝑛,称(𝒙,𝒚) = 𝒙𝑻𝒚 = 𝒚𝑻𝒙 = 累加1-n 的𝑥𝑖𝑦𝑖 为向量𝒙与𝒚的内积,称非负实数 ||𝒙||2= 根号(𝒙,𝒙) = 累加1-n的 𝑥𝑖2的1/ 2次方为向量𝒙的欧式范数.

    1. 向量的范数 /* vector norms */

    设𝑓 𝒙 = ||𝒙||为定义在𝑛维实空间ℝ𝑛上的实值函数, 如果满足条件:
    (1)正定性: 𝒙 ≥ 0, 𝒙 =0当且仅当𝒙 = 0时成立。
    (2)正齐次性: 𝑎𝒙 = 𝑎 ∙ 𝒙 ,∀𝑎 ∈ ℝ,∀𝒙 ∈ ℝ𝑛.
    (3)三角不等式:𝒙 + 𝒚 ≤ 𝒙 + 𝒚 ,∀𝒙,𝒚 ∈ ℝ𝑛.
    则称𝑓 𝒙 = ||𝒙||为𝑛维空间ℝ𝑛上的向量范数。

    由(3)可推出 𝒙 − 𝒚 ≤ ||𝒙 − 𝒚||.

    1. 向量范数的连续性定理

    设𝑓 𝒙 = ||𝒙||为ℝ𝒏上的任一向量范数,则𝑓(𝒙) 是𝒙的分量 𝑥1,𝑥2,…,𝑥𝑛的连续函数。

    1. 向量范数的等价性定理

    设 𝒙 𝒔, 𝒙 𝒕是向量空间ℝ𝒏上的任意两种范数,则存在常 数0 < 𝐶1 ≤ 𝐶2,使得 𝐶1 𝒙 𝒔 ≤ 𝒙 𝒕 ≤ 𝐶2 𝒙 𝒔,∀𝒙 ∈ ℝ𝒏.

    1. 向量收敛

    设有向量序列 {}𝒙}𝑘 ∈ ℝ𝒏,{𝒙}𝑘 = (𝑥1 𝑘,𝑥2 𝑘,…,𝑥𝑛 𝑘 )𝑻;;向量𝒙∗ ∈ ℝ𝒏,{𝒙}∗ =( 𝑥1 ∗,𝑥2 ∗,…,𝑥𝑛 ∗ )𝑻. .若lim 𝑘→∞{𝒙𝑖} 𝑘 = 𝒙𝑖 ∗ ,𝑖 = 1,2,…,𝑛,则称向量𝒙𝑘收敛于𝒙∗.记为:lim 𝒌→∞{𝒙}𝑘 = 𝒙∗.

    向量序列 {𝒙}𝒌 收敛于𝒙∗的充要条件是lim 𝒌→∞{𝒙}𝒌 − 𝒙∗ = 𝟎,其中|| ∙ || 是任意范数。

    1. 矩阵的范数

    设矩阵 ||𝑨||是定义在 ℝ𝑛×𝑛 上的某个实值函数,满足条件:
    (1)正定性:|| 𝑨 || ≥ 0, || 𝑨 || = 0当且仅当𝑨 = 0时成立。
    (2)正齐次性: || 𝑎𝑨 || =| 𝑎 |∙|| 𝑨 ||,∀𝑎 ∈ ℝ,∀𝑨 ∈ ℝ𝑛×𝑛
    (3)三角不等式: || 𝑨 + 𝑩 || ≤|| 𝑨 || + || 𝑩 || ,∀𝑨,𝑩 ∈ ℝ𝑛×𝑛
    (4)相容性: || 𝑨𝑩 || ≤ || 𝑨 || || 𝑩 || .
    则称 𝑨 是ℝ𝑛×𝑛的一个矩阵范数。

    1. 常用矩阵范数:
      (1)Frobenius 范数
      (2)算子范数
      向量范数与矩阵范数也应具备相容性: ||𝑨𝒙|| ≤|| 𝑨|| || 𝒙 ||

    设∀𝒙 ∈ ℝ𝑛,∀𝑨 ∈ ℝ𝑛×𝑛,|| ∙ || 𝑣是ℝ𝑛上的向量范数,记
    || 𝑨 || 𝑣 = max 𝑥≠0( ||𝑨𝒙|| 𝑣 / ||𝒙|| 𝑣 ),
    称|| 𝑨 ||𝑣是ℝ𝑛×𝑛上矩阵的范数,称为算子范数。

    设 ||𝒙 ||𝑣是ℝ𝑛上的向量范数, ||𝑨 ||𝑣是ℝ𝑛×𝑛上矩阵的算子范 数,则满足相容条件:|| 𝑨𝒙 || 𝒗 ≤ || 𝑨 ||𝒗 || 𝒙 || 𝒗.

    设𝑨 ∈ ℝ𝑛×𝑛的特征值为𝜆𝑖(𝑖 = 1,2,…,𝑛),称𝜌(𝑨) = max 1≤ 𝑖≤𝑛 |𝜆𝑖|,为矩阵𝑨的谱半径。

    设𝑨 ∈ ℝ𝑛×𝑛,则: 𝜌 (𝑨) ≤|| 𝑨 || , 其中 || 𝑨 || 是矩阵𝑨的算子范数

    1. 方程组的性态条件数与摄动理论阵范数
      (1) 𝑨与𝒃的摄动对方程组解的影响
      设有方程组𝑨𝒙 = 𝒃,其精确解为𝒙∗,𝑨非奇异,𝒃 ≠ 𝟎,则显然 解𝒙∗ ≠ 𝟎 。我们所要讨论的是𝑨和𝒃的微小误差𝜹𝑨和𝜹𝒃对方程组解 𝒙∗的影响。
      如果𝛿𝑨与𝛿𝒃微小变化,将引起𝛿𝒙很大变化,则称方程组𝑨𝒙 = 𝒃 为病态方程组,称𝑨为病态矩阵;反之如果𝛿𝑨与𝛿𝒃微小变化,引起 的𝛿𝒙变化很小,则称方程组为良态方程组,称𝑨为良态矩阵。
      (2)矩阵的条件数及其性质
      定义 设𝑨是非奇异矩阵,则𝒄𝒐𝒏𝒅 𝑨 = ||𝑨−𝟏|| || 𝑨 || 称为矩阵𝑨的 条件数,当条件数𝒄𝒐𝒏𝒅 𝑨 ≫ 𝟏时,则方程组是病态的, 当其较小是称方程组是良态的.
    2.线性方程组的数值解法
    • 直接法(适用于中等规模的n阶线性方程组)
      Gauss消去法及其变形
      矩阵的三角分解法

    • 迭代法(适用于高阶线性方程组)
      Jacobi迭代法
      Gauss-Seidel迭代法
      逐次超松弛法

    1. 高斯消去法 /* Gaussian Elimination */
      • 基本思想: 用逐次消去未知数的方法把原方程化为上三角形方程组进行求解。
      • 求解过程分为:
      消元过程:用初等行变换将原方程组的系数化为上三角形 矩阵(上三角阵);
      回代过程:对上三角形方程组的最后一个方程求解,将求得的解 逐步往上一个方程代入求解。
      主要包括高斯顺序消去法和高斯选主元消去法。
    展开全文
  • 线性方程数值解法2.ppt
  • 线性方程组数值解法实验线性方程组数值解法实验
  • 计算机数值方法教学课件第一章线性代数方程组数值解法-partii.ppt
  • 计算机数值方法教学课件第一章线性代数方程组数值解法-parti.ppt
  • 线性代数方程组数值解法及 MATLAB 实现综述 廖淑芳 20122090 数计学院 12 计算机科学与技术 1 班职教本科 一分析课题 随着科学技术的发展提出了大量复杂的数值计算 问题在建立 电子计算机成为数值计算的主要工具以后...
  • 1.数值解 1.1直接法(n较小) 1.1.1高斯消去法 1.1.2 直接三角形分解法 1.2迭代法(n较大) 针对求解问题预先设定某种迭代形式,产生求解问题的近似解迭代序列。在迭代序列收敛于精确解的情形下,按精度要求取...
  • 线性方程组数值解法(python) 上三角线性方程组 高斯消去法 上三角线性方程组 1.简介 NⅹN矩阵A=[aij]中的元素满足对所有i>j,有aij =0,则称矩阵A为上三角矩阵。如果A中的元素满足,对所有i<j,有aij =0...
  • 线性方程数值解法

    千次阅读 2018-12-30 20:48:48
    设有一个单变量的非线性方程f(x)=0f(x) = 0f(x)=0,往往这样的方程没有直接的求根公式,因此没有直接方法计算,只能使用迭代法来求数值解,二分法就是这样的一种方法,这里介绍一下其他的几种方法 不动点迭代法 我们...
  • 改程序基于线性方程组迭代解法——追赶法编写,主要解决工程中所需求解的大规模线性方程组问题。
  • 线性方程数值解法 初始近似值的搜索 方程的根 f(x∗)=0f(x^*)=0f(x∗)=0 ,x∗x^*x∗ 为 f(x)f(x)f(x) 的根 单根和重根 f(x∗)f(x^*)f(x∗) 有 mmm 重根 x∗x^*x∗ 的充要条件是 f(x∗)=f′(x∗)=⋯=f(m−...
  • 数值分析(3)-线性方程组直接解法

    千次阅读 2019-05-13 22:54:38
    文章目录3 线性方程组直接解法3.1 Gauss(高斯)消去法3.1.1 顺序高斯消去法3.1.2 列主元高斯消去法3.2 矩阵三角分解法3.2.1 高斯消去法的矩阵运算3.3.2 直接三角分解法3.3.3 平方根法3.3.4 追赶法 3 线性方程组直接...
  • 欧拉积分公式 复化积分公式 龙格库塔 使用MATLAB解决
  • function[x_star,k]=Newton1(fname,dfname,x0,ep,Nmax) %fname和dfname分别表示f(x)及其导数的M函数句柄; %x0为迭代初值;ep为精度 %x返回解,并显示计算过程,k为迭代次数上限以防发散 if nargin<...
  • 线性方程组数值解法可以分为直接法和迭代法两类。所谓直接法,就是经过有限步算术运算可求得方程组精确解的方法(不考虑舍入误差);而迭代法就是用某种极限过程去逐步逼近其精确解的方法。
  • 线性方程数值解法之二分法: 摘 要 : 摘要: 摘 要 : 求解非线性方程 f ( x ) = 0 f(x)=0 f ( x ) = 0 的数值解主要有二分法、简单迭代法以及 N e w t o n Newton N e w t o n 类迭代法等,本文主要介绍...
  • 首先综述了非线性方程组数值解法的研究现状、应用领域,并简述了其发展趋势,再着重介绍了迭代法、大范围收敛法、人工智能算法等实用性较强的方法.分析了当前的研究概况和水平,结合目前国内外研究成果总结了有待...
  • 数值计算——线性方程组解法

    千次阅读 2017-03-25 22:24:52
    数值计算——线性方程组解法 矩阵分解 矩阵分解是将矩阵拆解为数个矩阵的乘积,可分为三角分解、满秩分解、QR分解、Jordan分解和SVD(奇异值)分解等,常见的有三种: 1)三角分解法 (LU):将原正方矩阵分解成一个上...
  • 线性方程()数值解法线性方程()数值解法
  • 但是目前已知的数值解法并不完善,选择不同的方法,有着不同的收敛速度和计算量,而收敛速度和计算量影响着计算效率,所以数值解法的研究十分重要.58513本篇论文首先简单介绍了非线性方程组的几种经典数值解法,如...
  • 线性方程组数值解法 高斯消去法 顺序高斯消去法 通过初等变换消去方程组系数矩阵主对角线以下的元素,而使方程组化为等价的上三角形方程组 列主元高斯消去法 在每一次消元之前,将绝对值大的元素交换到主...
  • 计算方法丛书++非线性方程组数值解法(李庆扬+莫孜中+祁力群)

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 4,338
精华内容 1,735
关键字:

线性方程组数值解法