高斯消元法 （列主元素消元法 LU分解 高斯-赛德尔迭代法）+ 双点割线法 + 最小二乘法 + 拉格朗日插值法

最新推荐文章于 2022-12-17 10:57:35 发布
最新推荐文章于 2022-12-17 10:57:35 发布
阅读量1k 收藏 9
点赞数 2
文章标签： 高斯消元法 最小二乘法 拉格朗日插值法 双点割线法 二分法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_37428263/article/details/80113315
版权

1.列主元素消元法

//列主元素消元法
#include <iostream>
#include<cstdio>
#include<algorithm>
#include<cmath>
using namespace std;
typedef pair<double,int>PII;
const int maxn=100+5;
double maze[maxn][maxn];
int main()
{
    std::ios::sync_with_stdio(false);
    cin.tie(0);
    int n,kase=0;
    while(scanf("%d",&n)==1&&n)                                 //未知数的个数
    {
        for(int i=0;i<n;i++)
            for(int j=0;j<n+1;j++)
                 cin>>maze[i][j];
        for(int i=0;i<n-1;i++)
        {
            PII field[maxn];
            int k=0;
            for(int j=i;j<n;j++)
                field[k++]=PII(fabs(maze[j][i]),j);
            sort(field,field+k);
            int z=field[k-1].second;
            for(int k=i;k<n+1;k++)
                swap(maze[i][k],maze[z][k]);
            for(int k=i+1;k<n;k++)
            {
                double rat=maze[k][i]/maze[i][i];
                for(int j=i;j<n+1;j++)
                    maze[k][j]-=rat*maze[i][j];
            }
        }
        //从矩阵最后一行开始求解
        printf("Case %d:\n",++kase);
        double solve[maxn];
        for(int i=n-1;i>=0;i--)
        {
                for(int j=n-1;j>i;j--)
                {
                    double k=solve[j];
                    maze[i][n]-=k*maze[i][j];
                }
                double k=maze[i][n]/maze[i][i];
                solve[i]=k;
        }
        for(int i=0;i<n;i++)
            printf("%.5f%c",solve[i],i+1==n?'\n':' ');
    }
    return 0;
}

2.LU矩阵分解

#include <iostream>
#include<cstdio>
#include<cstring>
using namespace std;
const int maxn=100+5;
double maze[maxn][maxn];
int main()
{
    std::ios::sync_with_stdio(false);
    cin.tie(0);
    int n,kase=0;
    while(scanf("%d",&n)==1&&n)
    {
        for(int i=0;i<n;i++)
            for(int j=0;j<n+1;j++)
                cin>>maze[i][j];
        double A[maxn][maxn],L[maxn][maxn],U[maxn][maxn],b[maxn];
        for(int i=0;i<n;i++)
            for(int j=0;j<n+1;j++)
                if(j<n) {
                        A[i][j]=maze[i][j];
                }
                else {
                    b[i]=maze[i][j];
                }
        //根据A矩阵求解L及U矩阵
        memset(L,0,sizeof(L));
        for(int i=0;i<n;i++)
            L[i][i]=1;
        for(int i=0;i<n-1;i++)                          //指向标准行列
        {
            for(int k=i+1;k<n;k++)
            {
                double rat=A[k][i]/A[i][i];
                L[k][i]=rat;
                for(int j=i;j<n;j++)
                    A[k][j]-=rat*A[i][j];
            }
        }
        memcpy(U,A,sizeof(A));
        //Ly=b Ux=y
        printf("Case %d:\n",++kase);
        double Y[maxn],X[maxn];
        Y[0]=b[0];
        for(int i=1;i<n;i++)
        {
            for(int j=0;j<i;j++)
                b[i]-=Y[j]*L[i][j];
            Y[i]=b[i];
        }
        for(int i=n-1;i>=0;i--)
        {
                for(int j=n-1;j>i;j--)
                {
                    double k=X[j];
                    Y[i]-=k*U[i][j];
                }
                double k=Y[i]/U[i][i];
                X[i]=k;
        }
        for(int i=0;i<n;i++)
            printf("%.5f%c",X[i],i+1==n?'\n':' ');
    }
    return 0;
}

3.高斯-赛德尔迭代法

//高斯-赛德尔迭代法
//注意要达到严格对角优势
/*the test case
the input:
3
10 -1 -2 7.2
-1 10 -2 8.3
-1 -1 5 4.2
the output:
X1:1.10000
X2:1.20000
X3:1.30000
*/
#include <bits/stdc++.h>
using namespace std;
typedef pair<double,int>PII;
const int maxn=100+5;
double maze[maxn][maxn];
double str[maxn][maxn];
int main()
{
    std::ios::sync_with_stdio(false);
    cin.tie(0);
    int n;
    cin>>n;
    for(int i=0;i<n;i++)
        for(int j=0;j<n+1;j++)
             cin>>maze[i][j];
    //进行换行 确定方程
    for(int i=0;i<n;i++)
    {
        vector<PII>field;
        field.clear();
        for(int j=i;j<n;j++)
        {
            field.push_back(PII(fabs(maze[j][i]),j));
        }
        sort(field.begin(),field.end());
        int pos=field.size()-1;
        for(int j=0;j<n+1;j++)
            swap(maze[field[pos].second][j],maze[i][j]);
        for(int j=0;j<n;j++)
       {
           str[i][j]=(j==i?0:(-maze[i][j])/maze[i][i]);
       }
    }
    //设定初始值 进行迭代
    double solve[maxn];
    int cnt=0;
    memset(solve,0,sizeof(solve));
    while(true)
    {
        for(int i=0;i<n;i++)
        {
            solve[i]=0;
            for(int j=0;j<n;j++)
            {
                solve[i]+=solve[j]*str[i][j];
            }
            solve[i]+=maze[i][n]/maze[i][i];
        }
        cnt++;
        if(cnt==20) break;
    }
    for(int i=0;i<n;i++)
        printf("X%d:%.5f\n",i+1,solve[i]);
    return 0;
}

4.二分查找根

#include<bits/stdc++.h>
using namespace std;
double C(double k)
{
    return 1.0-k-sin(k);
}
int main()
{
    double lb=0,rb=1.0,mid;
    int cnt=0;
    while(rb-lb>0.0001)
    {
        mid=(lb+rb)/2.0;
        if(C(lb)*C(mid)<0) rb=mid;
        else lb=mid;
        cnt++;
    }
    printf("%.5f\n迭代次数为:%d\n",(rb+lb)/2.0,cnt+1);
    return 0;
}

5.双点割线法

//双点割线法
//f(x)=x*x*x-3*x+1  令x0=0.2 x1=0.5
#include<bits/stdc++.h>
using namespace std;
double solve(double x)
{
	return x*x*x-3*x+1.0;
}
int main()
{
	double x0=0.2,x1=0.5,x2;
	int t=8;
	while(t--)
	{
		x2=x1-(solve(x1)/(solve(x1)-solve(x0)))*(x1-x0);
		x0=x1;
		x1=x2;
	}
	printf("%.6f\n",x2);
	return 0;
}

6.拉格朗日插值法

//拉格朗日插值法 
#include<bits/stdc++.h>
using namespace std;
typedef pair<double,double>PII;
int main()
{
	//Ln(x)=y0*lo(x)+y1*l1(x)+.....+yn*ln(x)
	PII p[6];
	p[0]=PII(0.40,0.41075);
	p[1]=PII(0.55,0.57815);
	p[2]=PII(0.65,0.69675);
	p[3]=PII(0.80,0.88811);
	p[4]=PII(0.90,1.02652);
	p[5]=PII(1.05,1.25386);
	double solve=0.596,sum=0;
	for(int i=0;i<6;i++)
	{
		double k=1.0;
		for(int j=0;j<6;j++)
		{
			if(i!=j) {
				k*=(solve-p[j].first)/(p[i].first-p[j].first);
			}
		}
		sum+=p[i].second*k;
	}
	printf("%.5f\n",sum);
	return 0;
}

7.最小二乘法拟合多项式

//最小二乘法求多项式拟合 
#include<bits/stdc++.h>
using namespace std;
typedef pair<double,double>PII;
typedef pair<double,int>PII2;
const int maxn=100+5;
int main()
{
	std::ios::sync_with_stdio(false);
	cin.tie(0);
	int n;
	scanf("%d",&n);
	PII p[maxn];
	for(int i=0;i<n;i++)
	{
		cin>>p[i].first>>p[i].second;
	}
	int k;
	scanf("%d",&k);				
	//对称矩阵	再利用高斯消元法 
	double X[maxn][maxn],Y[maxn];
	memset(X,0,sizeof(X));
	for(int i=0;i<=k;i++)
	{
		for(int j=0;j<=k;j++)
		{
			if(i==0&&j==0) {
				X[i][j]=n;
				continue;
			}
			//起始次数和行数及列数相关 
			if(X[i][j]==0) {
				int fac=i+j;				//次数
				double sum=0.0; 
				for(int m=0;m<n;m++)
				{
					sum+=pow(p[m].first,fac);
				} 
				X[i][j]=X[j][i]=sum;
			}
			else continue;
		}	
	}
	//求Y矩阵
	for(int i=0;i<=k;i++)
	{
		double sum=0.0;
		for(int j=0;j<n;j++)
		{
			sum+=pow(p[j].first,i)*p[j].second;
		}
		Y[i]=sum;
	}
	//将X和Y矩阵合并 
	double solve[maxn][maxn];
	for(int i=0;i<=k;i++)
		for(int j=0;j<=k+1;j++)
		{
			if(j<=k) solve[i][j]=X[i][j];
			else if(j==k+1) solve[i][j]=Y[i];	
		}
	//利用高斯消元法
	for(int i=0;i<=k-1;i++)  
    {  
        PII2 field[maxn];  
        int cnt=0;  
        for(int j=i;j<=k;j++)  
            field[cnt++]=PII2(fabs(solve[j][i]),j);  
        sort(field,field+cnt);  
        int z=field[cnt-1].second;  
        for(int f=i;f<=k+1;f++)  
            swap(solve[i][f],solve[z][f]);  
        for(int f=i+1;f<=k;f++)  
        {  
            double rat=solve[f][i]/solve[i][i];  
            for(int j=i;j<=k+1;j++)  
                solve[f][j]-=rat*solve[i][j];  
        }  
    }
    //从矩阵最后一行开始求解 
    double s[maxn];  
    memset(s,0,sizeof(s));
    for(int i=k;i>=0;i--)  
    {  
        for(int j=k;j>i;j--)  
        {  
            double f=s[j];  
            solve[i][k+1]-=f*solve[i][j];  
        }  
        	double f=solve[i][k+1]/solve[i][i];  
            s[i]=f;  
    }
	printf("多项式拟合结果为:\n");  
    for(int i=0;i<=k;i++)  
        printf("X[%d]=%.6f\n",i+1,s[i]); 
    printf("多项式为:\nY=");
    for(int i=0;i<=k;i++)
    {
    	if(i==0) printf("%.6f",s[i]);
    	else printf("%.6fx^%d",s[i],i);
    	if(i+1==k+1) printf("\n");
    	else if(s[i+1]>0) printf("+");
	}
	return 0;
}

ALLACS
关注
  • 2
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
高斯消元法解多项式回归
weixin_55160419的博客
05-24 769
问题背景：给定一个单特征量、单输出值的数据集，找到一个拟合效果最佳的多项式关系，并预测其趋势。 基本思路：用预测值与真实值的差方和来表征多项式的拟合效果，称为损失函数，损失函数极值点即为最佳拟合效果的参数，而多元函数的极值点可以通过求偏导并联立方程组解得。 具体过程：1.求损失函数偏导，得到线性方程组： void ini() { for (int i=1;i<=30;i++) for (int j=0;j<=5;j++) ...
高斯消去法、高斯赛德尔迭代法与雅各比迭代法的matlab实现
qq_58564903的博客
06-05 1193
高斯消去法 function x = gauss(A,b) n = length(b); x = zeros(n,1); for i = 1:n-1 if A(i,i) == 0 fprintf("error"); return; end for k = (i+1:n) m = -A(k,k)/A(i,i); A(k,i:n) = A(k,i:n) + m * A(i,i:n); b(k) = b(k) + m * b(i);...
基于列主元高斯消去法的最小二乘法曲线拟合
10-10
采用基于列主元的高斯消去法做的最小二乘法曲线拟合
matlab最小二乘法和高斯消元,最小二乘法与高斯消元法.ppt
weixin_36199116的博客
03-22 262
最小二乘法与高斯消元法2.4 正交多项式和最佳平方逼近 　　正交多项式是数值计算中的重要工具，这里只介绍正交多项式的基本概念、某些性质和构造方法。离散情形的正交多项式用于下节的数据拟合，连续情形的正交多项式用于生成最佳平方逼近多项式和下章的高斯型求积公式的构造。它们在数值分析的其他领域中也有不少应用。 2.4.1 离散点集上的正交多项式 设有点集 ，函数 　和 ...
高斯消元法
李田所的博客
12-17 529
高斯消元法C语言实现。代码已经通过洛谷高斯消元模板题AC验证了
3_6.rar_高斯 - 赛德尔 迭代法 -- 源代
09-23
在处理大型线性系统时，直接求解如高斯消元法可能会面临计算量过大和存储需求高的问题，而迭代法则提供了一种更灵活、更节省资源的解决方案。 首先，我们要理解线性方程组的一般形式：Ax = b，其中A是一个n×n的...
Jacobi-雅可比迭代法、高斯-赛德尔迭代法.zip
10-23
在数值计算领域，雅可比迭代法（Jacobi Iteration）和高斯-赛德尔迭代法（Gauss-Seidel Iteration）是解决大型线性系统的重要算法，它们主要用于求解形如 Ax=b 的线性方程组，其中A是系数矩阵，x是未知数向量，b是...
gs.zip_Gauss-Seidel_数值线性代数_维弗法_高斯-赛德尔迭代_高斯赛德尔
09-20
实现高斯赛德尔迭代求解线性方程组，原系数矩阵...高斯-赛德尔迭代（Gauss–Seidel method）是数值线性代数中的一个迭代法，可用来求出线性方程组解的近似值。该方法以卡尔·弗里德里希·高斯和路德维希·赛德尔命名。
MATLAB雅克比迭代法（Jacobi method）和高斯-赛德尔迭代法（Gauss–Seidel method）求Ax=b
12-26
在数值分析领域，雅克比迭代法（Jacobi method）和高斯-赛德尔迭代法（Gauss–Seidel method）是求解大型线性系统Ax=b的有效算法，尤其是在计算机科学和工程计算中广泛使用。MATLAB作为一种强大的数学计算软件，提供...
高斯赛德尔迭代法.rar
最新发布
01-06
基于MATLAB编程，高斯赛德尔迭代法，代码完整，包含数据，有注释，方便扩展应用 1，如有疑问，不会运行，可以私信, 2，需要创新，或者修改可以扫描二维码联系博主, 3，本科及本科以上可以下载应用或者扩展， 4，内容...
最小二乘法及方程曲线(VB6.0代码)
11-19
最小二乘法及方程曲线(VB6.0代码) 本程序是任给出两组对应值，通过三次拟合，求出一元三次方程的系数，并画出一元三次方程的曲线。 并可载入数据，免去每都要输入。对需要最小二乘法的人，是不可多得的。下载后，把文件放到E盘根目下。 本程序是作者花了很时间完成的，希望对大家有所帮助。更希望能提出建议。
LU分解法，列主元三角分解法MATLAB代码（按行）
10-08
LU分解法且是列主元三角分解法MATLAB代码，有详细注释，顺着思路看容易理解
数值计算方法习题解答案
05-12
中国矿业大学出版社的数值计算方法习题答案
列主元消去法实验报告
10-27
列主元素消去法是为控制舍入误差而提出来的一种算法,在Gauss消去法的消元过程中,若出现 =0,则消元无法进行,即使其不为0,但很小,把它作为除数,就会导致其他元素量级的巨大增长和舍入误差的扩散,最后使计算结果不可靠.使用列主元素消去法计算,基本上能控制舍入误差的影响,并且选主元素比较方便.
洛谷 - P4783 【模板】矩阵求逆(高斯消元求逆矩阵)
Falcon的博客
08-28 376
题目链接：点击查看 题目大意：给出一个 n * n 的矩阵，求出其逆矩阵，mod 为 1e9 + 7，若不存在输出No Solution 题目分析：囤个模板，原理就是，初始时在原矩阵右侧设置一个单位矩阵，随着原矩阵进行高斯消元的过程，单位矩阵也跟随进行一系列的变换，当原矩阵变为单位矩阵时，单位矩阵也就变成了逆矩阵，符号语言就是： 代码： #include<iostream> #include<cstdio> #include<string> #include&.
《算法竞赛-训练指南》第二章-数论_高斯消元
李硕
08-20 756
矩阵是个神奇的东西，也是线性代数求解当中很重要的一个工具。 线性方程组求解的时候，就要用到矩阵。 增广矩阵求解的过程还是比较简单的，就是很久就学过的高斯消元，只不过是以前不这样叫，没有系统的方法执行出来说明什么样的步骤才是真正正确的步骤。 这个在自己学线性代数的时候其实就应该懂的。实现起来，其实就是一个用语言来实现思想的事。 贴出代码： #include #include #incl
雅可比迭代法、高斯 - 赛德尔迭代法和SOR迭代法的实现
真男人从不回头看进球
07-15 1万+
雅可比迭代法： 高斯-赛德尔迭代法： SOR迭代法： import numpy as np import numpy.linalg as nl def MaxOfList(A): max = A[0] for i in range(0, len(A)): if A[i] &gt; max: max =...
算法#03--详解最小二乘法原理和代码
热门推荐
tclxspy的博客
04-22 1万+
最小二乘法的目标：求误差的最小平方和，对应有两种：线性和非线性。线性最小二乘的解是closed-form（如下文），而非线性最小二乘没有closed-form，通常用迭代法求解（如高斯牛顿迭代法，本文不作介绍）。
数值方法双点割线法解非线性方程
weixin_43625164的博客
03-03 856
计算x^3-3*x-1=0的根,取x0=2,x1=1.8,精确到四位小数 public class Secant { final static double WUCHA=0.00005;//误差 static double hanshu2(double x) { var v = x * x * x - 3.00000 * x - 1.00000; r...
高斯赛德尔迭代法VS2010c++
06-02
高斯赛德尔迭代法是一种求解线性方程组的方法，可以用C++语言实现。以下是一个基于VS2010的C++代码示例，用于求解线性方程组Ax=b的解： ```c++ #include #include using namespace std; int main() { double a[3]...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值