利用高斯消元法及LU分解法解方程组(C、Java)

最新推荐文章于 2024-01-25 11:28:21 发布
最新推荐文章于 2024-01-25 11:28:21 发布
阅读量2.6k 收藏 23
点赞数 3
分类专栏： 其他 文章标签： java 算法 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zry15671554200/article/details/109784042
版权

1. 描述

  高斯消元法是将方程组中的一方程的未知数用含有另一未知数的代数式表示，并将其代入到另一方程中，这就消去了一未知数，得到一解；或将方程组中的一方程倍乘某个常数加到另外一方程中去，也可达到消去一未知数的目的。消元法主要用于二元一次方程组的求解。

核心
  1) 两方程互换，解不变；
  2) 一方程乘以非零数k，解不变；
  3) 一方程乘以数k加上另一方程，解不变

2. 人工求解方式

人工求解方式如下：
image.png

3.程序求解

只要理解了算法思路，用不同语言实现代码过程类似。算法思想如下：

1.设置变量colNum值为矩阵列数，则可利用一维数组存储矩阵中所有元素。
2.选择主元，即选择对角元素，保证其绝对值为所在列的最大，避免大数除以小数出现溢出，其实是避免其值为0。
3.当前主元不为最大值，交换两行。
4.判断主元是否为0，若是则不是唯一解。
5.逐行消元。
6.对角线元素归一化。
7.回代消除对角线之上的元素。

其中会产生一些疑问：

3.1 为何要选择主元？

  在计算机执行消去法时，要将一行是第一个元素化为1，即该行各元素同除以第一个非零元素，如果这个元素的绝对值非常小，就会导致该行其它元素变得绝对值非常大，在与其它行对应元素执行加减运算时会把其它行的元素忽略不计，使得误差增大，为了避免出现这种情况，编制程序的时候增加了选主元的步骤。这主要是因为计算机进行的是近似计算，如果是用准确数运算，选主元的步骤是不必要的。

3.2 为什么计算机进行的是近似计算？

  因为计算机存储小数的方式决定了计算机在进行浮点数运算时有可能存在误差。例如一个经典面试题，在计算机中，使用IEEE754标准存储浮点数时计算结果如下：
    0.1 + 0.2 = 0.30000000000000004
  因为 0.1和0.2在使用IEEE754标准存储时，在计算机中存储结果为：
    0.1: 0.00011001100110011……(循环0011)
    0.2: 0.0011001100110011…….(循环0011)
  但计算机不可能存储无限长度的数，故会根据设置的数据格式长度来截取，32或64位，这样就会造成数据精度丢失。

3.3 代码实现

3.3.1 C语言
#include <stdio.h>
#include <stdlib.h>
#include <math.h>

bool resolveByGauss(double[], int, int);
void printArrayInfo(double[], int, int);
int selectPivotalElement(double[], int, int, int);
void swapCol(double[], int, int, int);
void emissElement(double[], int, int, int);
void elementBack(double[], int, int, int);
void backEmiss(double[], int, int);
void printArrayInfo(double[], int);



int main(int argc, char *argv[]) {
	//创建题中所示矩阵
	double array[12] = {1, -3, 5, 0, 2, -1, -3, 11, 2, 1, -3, 5};
	//计算数组长度
	int arrayLength = sizeof(array) / sizeof(array[0]);
	printf("题中的增广矩阵\n");
	printArrayInfo(array, 4, arrayLength);
	//执行运算
	resolveByGauss(array, 4, arrayLength);
	printf("高斯消元后的矩阵\n");
	printArrayInfo(array, 4, arrayLength);
}

/**
 * 利用高斯消元法计算
 * @param array  系数矩阵 增广矩阵
 * @param colNum 列向量个数（从第0列开始）
 * @param arrayLength 数组的长度
 * @return boolean 是否得出结果
 */
bool resolveByGauss(double array[], int colNum, int arrayLength) {
	//行数
	int rows = arrayLength / colNum;

	//逐行选择主元              第 i 行 ，第i列  的元素（i，i）
	for (int i = 0; i < rows; i++) {
		//按列选择主元
		int pivotRow = selectPivotalElement(array, colNum, i, arrayLength);
		//如果主元不是目前所在的i列，则交换
		if (pivotRow != i) {
			swapCol(array, pivotRow, i, colNum);
		}
		if (array[i * colNum + i] == 0) {
			printf("不含有唯一解");
			return false;
		}
		//消元得到上三角
		for (int j = 0; j < colNum; j++) {
			emissElement(array, j, colNum, arrayLength);
		}
	}
	//主元素归一化
	for (int i = 0; i < rows; i++) {
		elementBack(array, i, colNum, arrayLength);
	}
	//回代消元，从最后一行开始
	for (int i = rows - 1; i > 0; i--) {
		backEmiss(array, i, colNum);
	}
	return true;
}

/**
 *	逐行选择主元
 * @param array
 * @param colNum
 * @param i  第i行的主元
 * @return 主元所在的列
 */
int selectPivotalElement(double array[], int colNum, int i, int arrayLength) {
	//返回的所选择的主元所在列的索引
	int pivotColIndex = 0 ;
	//中间变量
	double max = 0;
	for (int j = i * colNum + i; j < arrayLength; j += colNum) {
		if (fabs(max) < fabs(array[j])) {
			max = array[j];
			pivotColIndex = j;
		}
	}
	//返回主元所在的行
	return pivotColIndex / colNum;
}

/**
 * 交换两行
 *
 * @param array
 * @param dist   目标行
 * @param src    原来的行
 * @param colNum 行向量的长度
 */
void swapCol(double array[], int dist, int src, int colNum) {
	int distance = (dist - src) * colNum;
	for (int j = src * colNum; j < (src + 1) * colNum; j++) {
		double temp = array[j];
		array[j] = array[j + distance];
		array[j + distance] = temp;
	}
}


/**
 * 逐行消元
 * @param array
 * @param i      标示第 i 行的主元
 * @param colNum
 */
void emissElement(double array[], int i, int colNum, int arrayLength) {
	//矩阵行数
	int len = arrayLength / colNum;
	//第i+1行开始消元
	for (int j = (i + 1); j < len; j++) {
		//消元系数
		double index = array[j * colNum + i] / array[i * colNum + i];
		int ii = i * colNum + i;
		for (int k = j * colNum + i; k < (j + 1) * colNum; k++, ii++) {
			array[k] = array[k] - array[ii] * index;
		}
	}
}

/**
 * 元素归一化处理
 * @param array
 * @param i      第 i 行 归一化处理
 * @param colNum 矩阵列数 ，每行元素个数
 */
void elementBack(double array[], int i, int colNum, int arrayLength) {
	//每行的长度
	int len = arrayLength / colNum;
	double factor = array[i * colNum + i];
	for (int j = i * colNum + i; j < (i + 1) * colNum; j++) {
		array[j] = array[j] / factor;
	}
}

/**
 * 回代消元
 * @param array
 * @param i      第i行之上的开始消除
 * @param colNum 矩阵每一行的个数
 */
void backEmiss(double array[], int i, int colNum) {
	for (int j = i; j > 0; j--) {
		double factor = array[(j - 1) * colNum + i];
		array[(j - 1) * colNum + i] = 0;
		array[j * colNum - 1] = array[j * colNum - 1] - array[(i + 1) * colNum - 1] * factor;
	}
}

/**
 * 打印输出信息
 * @param array
 * @param colNum
 */
void printArrayInfo(double array[], int colNum, int arrayLength) {

	for (int i = 0; i < arrayLength; i++) {
		printf("%f\t", array[i]);
		if ((i + 1) % colNum == 0) {
			printf("\n");
		}
	}
}
3.3.2 Java
package com.hubu.meetingroom.util;

import java.math.BigDecimal;

/**
 * @author zry
 * @date 2020-11-17 16:11:17
 */
public class GaussUtil {

        /**
         * 除法精度（除不尽时保留10为小数）
         */
        private static final int DIV_SCALE = 10;

        /**
         * @param array  系数矩阵 增广矩阵
         * @param colNum 列向量个数（从第0列开始）
         * @return boolean 是否得出结果
         */
        public static boolean resolveByGauss(double[] array, int colNum) {
                //行数
                int rows = array.length / colNum;
                //逐行选择主元              第 i 行 ，第i列  的元素（i，i）
                for (int i = 0; i < rows; i++) {
                        //按列选择主元
                        int pivotRow = selectPivotalElement(array, colNum, i);
                        //如果主元不是目前所在的i列，则交换
                        if (pivotRow != i) {
                                swapCol(array, pivotRow, i, colNum);
                        }
                        if (array[i * colNum + i] == 0) {
                                System.out.println("不含有唯一解");
                                return false;
                        }
                        //消元得到上三角
                        for (int j = 0; j < colNum; j++) {
                                emissElement(array, j, colNum);
                        }
                }
                //主元素归一化
                for (int i = 0; i < rows; i++) {
                        elementBack(array, i, colNum);
                }
                //回代消元，从最后一行开始
                for (int i = rows - 1; i > 0; i--) {
                        backEmiss(array, i, colNum);
                }
                return true;
        }

        /**
         * 回代消元
         * @param array
         * @param i      第i行之上的开始消除
         * @param colNum 矩阵每一行的个数
         */
        private static void backEmiss(double[] array, int i, int colNum) {
                for (int j = i; j > 0; j--) {
                        double factor = array[(j - 1) * colNum + i];
                        array[(j - 1) * colNum + i] = 0;
                        array[j * colNum - 1] = sub(array[j * colNum - 1] ,array[(i + 1) * colNum - 1] * factor);
                }
        }

        /**
         * 元素归一化处理
         * @param array
         * @param i      第 i 行 归一化处理
         * @param colNum 矩阵列数 ，每行元素个数
         */
        private static void elementBack(double[] array, int i, int colNum) {
                //每行的长度
                int len = array.length / colNum;
                double factor = array[i * colNum + i];
                for (int j = i * colNum + i; j < (i + 1) * colNum; j++) {
                        array[j] = div(array[j],factor);
                }
        }


        /**
         * 逐行消元
         *注意浮点数加减乘除的结果不精确，需要使用BigDecimal对运算过程进行处理
         * @param array
         * @param i      标示第 i 行的主元
         * @param colNum
         */
        private static void emissElement(double[] array, int i, int colNum) {
                //矩阵行数
                int len = array.length / colNum;
                //第i+1行开始消元
                for (int j = (i + 1); j < len; j++) {
                        //消元系数
                        double index = div(array[j * colNum + i],array[i * colNum + i]);
                        int ii = i * colNum + i;
                        for (int k = j * colNum + i; k < (j + 1) * colNum; k++, ii++) {
                                array[k] = sub(array[k],array[ii] * index);
                        }
                }
        }

        /**
         * 交换两行
         *
         * @param array
         * @param dist   目标行
         * @param src    原来的行
         * @param colNum 行向量的长度
         */
        private static void swapCol(double[] array, int dist, int src, int colNum) {
                int distance = (dist - src) * colNum;
                for (int j = src * colNum; j < (src + 1) * colNum; j++) {
                        double temp = array[j];
                        array[j] = array[j + distance];
                        array[j + distance] = temp;
                }
        }

        /**
         *
         * @param array
         * @param colNum
         * @param i  第i行的主元
         * @return 主元所在的列
         */
        private static int selectPivotalElement(double[] array,int colNum,int i) {
                //返回的所选择的主元所在列的索引
                int pivotColIndex = 0 ;
                //中间变量
                double max = 0 ;

                for (int j = i*colNum + i; j < array.length; j+=colNum) {
                        if(Math.abs(max)<Math.abs(array[j])){
                                max = array[j];
                                pivotColIndex = j ;
                        }
                }
                //返回主元所在的行
                return pivotColIndex/colNum;
        }

        /**
         * 打印输出信息
         * @param array
         * @param colNum
         */
        public static void printArrayInfo(double[] array,int colNum){
                for (int i = 0; i < array.length; i++) {
                        System.out.print(array[i]+" ");
                        if((i+1)%colNum==0){
                                System.out.println();
                        }
                }
        }

        public static void main(String[] args) {
                //float[] array = new float[]{2,3,11,5,2,1,1,5,2,1,2,1,3,2,-3,1,1,3,4,-3};
                double[] array = new double[]{1,-3,5,0,2,-1,-3,11,2,1,-3,5};
                System.out.println("题中的增广矩阵");
                printArrayInfo(array,4);
                GaussUtil.resolveByGauss(array,4);
                System.out.println("高斯消元后的矩阵");
                printArrayInfo(array,4);
        }

        /** 小数精确减法  */
        public static double sub(double d1,double d2)
        {
                BigDecimal bd1 = BigDecimal.valueOf(d1);
                BigDecimal bd2 = BigDecimal.valueOf(d2);
                return bd1.subtract(bd2).doubleValue();
        }

        /** 小数精确除法   */
        public static double div(double d1,double d2)
        {
                BigDecimal bd1 = BigDecimal.valueOf(d1);
                BigDecimal bd2 = BigDecimal.valueOf(d2);
                /*
                 * 当除不尽时，以四舍五入的方式（关于除不尽后的值的处理方式有很多种）保留小数点后10位小数
                 */
                return bd1.divide(bd2, DIV_SCALE, BigDecimal.ROUND_HALF_UP).doubleValue();
        }
}

最终求解后，结果如下，与预期结果一致。
demo

4. 总结

  1. 高斯消元法在程序中的使用需要注意浮点数运算的精度问题，否则可能会造成很大的误差。故需要选择主元之后再进行其他步骤。（消除主元法也称为列主元素消去法）

  2. 该方法可适用于n元一次方程组的求解。

5. LU分解法

5.1 LU分解法的算法思路

  1. 将系数矩阵A通过初等行变换将其变为一个上三角矩阵U，然后，将原始矩阵A变为上三角矩阵的过程，对应的变换矩阵为一个下三角矩阵L，即分解为下三角矩阵 L 和一个上三角矩阵 U 的乘积，将Ax=b转换为LUx=b
  2. 计算Ly=b
  3. 计算Ux=y
  4. 回带消元

5.2 代码实现

以下代码为C++实现的代码：

#include <iostream>
#include <Windows.h>
using namespace std;

double **init_Matrix(int r, int c) {
	double **p = new double* [r];
	int d = c + 1;
	for (int i = 0; i < r; i++) {
		p[i] = new double[d];
		memset(p[i], 0, sizeof(double) * d);
	}
	cout << "请输入线性方程组对应的增广矩阵:" << endl;

	for (int i = 0; i < r; i++) {
		for (int j = 0; j < d; j++) {
			cin >> p[i][j];
		}
	}
	return p;
}

//直接用A来储存LU和方程组右边的常数项 进行LU分解时 右边常数项不做处理 即最后一列全部不处理
void LU_Position(double **a, int r, int c) {
	double num1 = 0, num2 = 0;
	for (int i = 0; i < r; i++) {
		if (i == 0) {
			for (int j = 1; j < c; j++) {
				a[j][i] = a[j][i] / a[0][0];
			}


		} else {
			for (int j = i; j < c; j++) {
				num1 = 0;
				for (int k = 0; k < i; k++) {
					num1 += a[i][k] * a[k][j];
				}
				a[i][j] = a[i][j] - num1;
			}
			for (int j = i + 1; j < r; j++) {
				num2 = 0;
				for (int k = 0; k < i; k++) {
					num2 += a[j][k] * a[k][i];
				}
				a[j][i] = (a[j][i] - num2) / a[i][i];
			}
		}
	}
	cout << "所得的LU矩阵为:" << endl;
	for (int k = 0; k < r; k++) {

		for (int n = 0; n < c; n++) {
			printf("%f\t", a[k][n]);
		}
		cout << endl;
	}
}

void calculate(double *y, double *x, double **a, int r) {
	y[0] = a[0][r];
	double sum = 0;
	for (int i = 1; i < r; i++) {
		sum = 0;
		for (int k = 0; k < i; k++) {
			sum += a[i][k] * y[k];
		}
		y[i] = a[i][r] - sum;
	}
	cout << "所求的向量Y为:" << endl;
	for (int i = 0; i < r; i++) {
		printf("%f\t", y[i]);
	}
	cout << endl;
	for (int i = r - 1; i >= 0; i--) {
		sum = 0;
		for (int j = i + 1; j < r; j++) {
			sum += a[i][j] * x[j];
		}
		x[i] = (y[i] - sum) / a[i][i];
	}
	cout << "所求线性方程组的解向量X为:" << endl;
	for (int i = 0; i < r; i++) {
		printf("%f\t", x[i]);
	}
	cout << endl;
}

void LU_position_main() {
	cout << "输入矩阵的行列:" << endl;
	int i = 0, j = 0;
	cin >> i >> j;
	double **p = init_Matrix(i, j);
	LU_Position(p, i, j);
	double *a = new double[i];
	memset(a, 0, sizeof(double) * i);
	double *b = new double[i];
	memset(b, 0, sizeof(double) * i);
	calculate(a, b, p, i);
	delete[]a;
	delete[]b;
	for (int i = 0; i < j; i++) {
		delete[]p[i];
	}
	delete[]p;
}

int main(void) {
	LU_position_main();
	system("pause");
	return 0;
}

最终结果如下,与预期相符：
image.png

你知道的越多，你不知道的越多，欢迎访问我的blog：http://www.codinglemon.cn/

CodingLemon.
关注
  • 3
    点赞
  • 踩
  • 23
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
LU分解法解线性方程组（C语言）
04-30
使用LU分解法，来解线性方程组，用C语言写的源程序
C/C++ 语言实现使用LU分解求解线性方程组
原野拓荒的博客
05-14 2621
应用计算方法C语言程序：02 接 应用计算方法C语言程序：01 以计算方法课本例题4-6为例。 设矩阵A,b分别为：A[3][3] = { {1,3,3},{2,1,1},{2,3,4} }; b[3] = { 1,2,1 }; 利用C语言程序求解方程组如下：（其中LU分解程序见应用计算方法C语言程序：01） 程序中矩阵求逆部分程序使用了博友（重中之重小星星 ）的程序（感谢博主的分享）：原文链接 void Matrix_inverse(double arc[3][3], int n, double
LU分解原理解释及C语言实现
Aysek的博客
08-26 4292
本文为笔者在编写spice时，需利用LU求解线性方程组时所写。 1、杜尔里特算法： 从下至上对矩阵A做初等行变换，将对角线左下方的元素编成零，即得到U矩阵。然后可以证明这些行变换的效果等同于左乘一系列单位下三角矩阵，这一系列单位下三角矩阵的乘积的逆就是L矩阵，它也是一个单位下三角矩阵。即杜尔特里算法证实了矩阵A可以唯一分解成为L和U矩阵。 2、LU分解原理概要： 将方程组的系数矩阵分解为两个三角矩阵的乘积，以四阶为例进行讨论，即 ...
解线性方程组的直接方法:LU分解法及其C语言算法实现
weixin_45416439的博客
03-07 4646
在上一篇博客里面,笔者介绍了解线性方程组的列主元Guass消元法,这篇将介绍LU分解法及其算法实现. 什么是LU分解? 对于一个线性方程组Ax=b,其中A是非奇异系数矩阵,b是线性方程组右端项,在列主元Guass消元法里面我们知道,最后的系数矩阵A将变成一个上三角矩阵,并且是通过一系列的行变换而来的,设最后得到的上三角矩阵为U,结合高等代数的知识,一个矩阵左乘一个初等矩阵,相当于进行一次行变换,因...
Python基于高斯消元法计算线性方程组示例
09-20
高斯消元法是线性代数中一种求解线性方程组的常用方法，其基本思想是通过一系列行变换将系数矩阵转化为阶梯形或简化阶梯形矩阵，从而求得方程组的解。在Python中实现高斯消元法，我们可以编写一个函数来处理这个过程...
三种线性方程组求解方法的串行算法，和并行算法。包含高斯消元法，LU分解法，追赶法。
06-17
使用CUDA实现的线性方程组的求解并行化。
gaosixiaoyuan.rar_gauss_数值算法_线性方程组_高斯消元_高斯消元法
09-21
数值算法在处理线性方程组时，除了高斯消元法，还有其他方法，如高斯-约旦消元法、LU分解、QR分解等。每种方法都有其适用场景和优缺点，比如高斯消元法简单直观，但当矩阵规模较大或存在接近于0的元素时，可能会导致...
LU分解法解方程组
12-15
一旦得到L和U，就可以通过向前替换和向后替换两个步骤来求解原方程组，而无需使用高斯消元法中的部分 pivoting。 首先，我们需要理解线性方程组的一般形式： Ax = b 其中，A是一个n×n的系数矩阵，x是一个n维列...
线性方程组消去法求解 高斯消元 追赶法 数值计算作业
12-15
解决线性方程组的方法有很多，其中高斯消元法和追赶法是两种常用的数值计算方法。 高斯消元法，又称为高斯-约旦消元法，是基于矩阵运算的一种求解线性方程组的策略。这种方法通过一系列行变换（包括交换两行、将某...
线性方程组的求解-列主元消元法,LU分解法,改进的平方根法，追赶法和雅可比迭代，高斯—塞德尔迭代
04-06
在科技研究和工程技术所提出的计算问题中，经常会遇到线性方程组的求解问题，这里主要是有关线性方程组的直接解法。解线性方程组的直接法是用有限次运算求出线性方程组 Ax=b 的解的方法。线性方程组的直接法主要有Gauss消元法及其变形、LU(如Doolittle、Crout方法等)分解法和一些求解特殊线性方程组的方法（如追赶法、LDLT法等）。这里主要有列主元消元法,LU分解法,改进的平方根法，追赶法和雅可比迭代，高斯—塞德尔迭代 的构造过程及相应的程序。线性方程的解法在数值计算中占有极重要的地位，因此，线性方程组的求解是数值分析课程中最基本的内容之一。
LU矩阵分解法解线性方程组（C++实现）
py753159123456的博客
10-28 1607
LU矩阵分解法解线性方程组（C++实现） #include<cstdio> #include<iostream> using namespace std; void fenjie(double a[],double b[],int n){ double aa[n][n]; for(int i=0;i<n;i++){ for(int j=0;j<n;j++){ aa[i][j]=a[n*i+j]; } } double l[n][n]; do
C语言实现方程组LU分解法和列主元LU分解法
mohenxiang的博客
12-17 3154
根据老师所讲LU分解法和列主元LU分解法本质就是高斯消去法和列主元高斯消去法， 将L部分变为都变为0，则就化为高斯消去法，我们在方程求回代的过程中只用到了U和y，不需要用到L，那个L部分实际保存了每一次运算的倍数关系，详细可自己举数学例子验证便可知。 以例子解释规律，我们以（1，1）表示第一行第一列数,则（3，1）表示第三行第一列，那么第一行所有数保持不变，第一列数全部除上第一行第一列。然后原来（2，2）-(2,1)*(1,2)即：5-0.7*7。 6-0.7*8，5-0.7*7而第二列为（6-0.
解线性方程组之LU分解算法实现
qq_41989372的博客
12-04 4560
一：实验目的： 1. 掌握LU分解算法原理； 2. 使用C语言编程实现LU分解算法。 二：实验要求 用LU分解算法求解给定的线性方程组 。 函数接口定义： bool Direct( int n, double a[][MAX_SIZE], double b[] )。 在Direct的接口定义中，n为矩阵a的维数，MAX_SIZE是由裁判程序定义的矩阵最大维数，b是方程组中的常向量，求得的解将存储在...
C语言线性方程组求解：LU分解、雅可比迭代、高斯-赛德尔迭代
最新发布
jk_lovers的博客
01-25 1381
（注：该程序C和C++通用）我们知道在Matlab中，矩阵的求解是非常方便的，对于Ax = b，只需要做x = A \ b的运算就可以得到x的结果，然而对于C语言，我们就需要寻找一些算法来实现线性矩阵的求解。由于本学期刚学完数值分析，并且目前做的项目中刚好有需要求解线性方程组的需求，于是将求解线性方程组的三种方法（其实还有更多，我这里仅给出三种）：LU分解、雅可比迭代以及高斯-赛德尔迭代。这三个算法的基本原理就不过多赘述了，大家想进一步学习的可以网上搜，一大堆教程，而且原理也较为简单。
用直接分解法求方程组的C语言程序,LU分解法解线性方程组（C语言）
weixin_42449583的博客
05-19 682
#include #include #define N 10 //矩阵大小范围/** 使用已经求出的x，向前计算x(供getx()调用)* float a[][]矩阵U* float x[]方程组解* inti解的序号(数组X元素序号)* intn矩阵大小* return公式中需要的和*/float getmx(float a[N][N], float x[N], int i, int n){fl...
矩阵的LU分解求解线性方程组(C++实现）
zhutou1280的博客
11-07 2万+
继续解方程组，这次使用LU分解求解方程组的解，该方法思想就是将一个矩阵分解为一个单位下三角矩阵L和一个上三角矩阵U，属于矩阵的三角分解法，又称杜利特尔（Doolittle）分解。其实高斯消元法的进行的每一步消元操作，都是等于左乘一个初等置换阵。具体的该方法的证明在数值分析或者线性代数的课本上应该都有，在这就不给出证明和说明了。本篇文章主要给出具体的C++实现过程。 还是老样子，先贴代码吧！
数值计算大作业：线性方程组求解（LU分解与Chloesky分解程序在Matlab与C的实现）
qq_37262461的博客
10-12 1518
我把矩阵直接求解的LU分解法与Chloesky分别在MATLAB和C语言中编程实现。具体的程序详细标注后放在文章最后了，需要的同学自取。
Java——(高斯消去法/列主元消去法/LU消去)求解方程
热门推荐
GodOuO
11-08 2万+
Java的高斯/列高斯消去法，求解方程
C/C++ 语言实现矩阵LU分解
原野拓荒的博客
05-14 3638
LU分解又叫做Doolittle分解。 Ax=b,A为方阵时，对矩阵A的LU分解矩阵L、U公式如下图： 对矩阵A的LU分解C代码如下： #include <iostream> #include "math.h" using namespace std; double L[3][3] = { 0 }, U[3][3] = { 0 }; void Doolittle(double a[3][3]) { for (int i = 0; i < 3; i++) { //更新L矩阵
高斯消元法与lu分解区别
06-07
高斯消元法和LU分解都是求解线性方程组的方法，但它们的实现方式和结果表现上有一些区别。 高斯消元法是一种直接求解线性方程组的方法，它将系数矩阵进行行变换，把它变为一个上三角矩阵，然后通过回带求解得到方程...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值