计算方法 c++代码

最新推荐文章于 2024-02-11 23:21:46 发布
最新推荐文章于 2024-02-11 23:21:46 发布
阅读量503 收藏 12
点赞数 7
分类专栏： 计算方法 文章标签： c++ 计算方法 数值分析 数学
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sylviiiiiia/article/details/134708290
版权

环境 ：Windows 10 + Dev-C++ 5.11

Lagrange 插值方法

Lagrange 插值多项式： 在这里插入图片描述

#include<bits/stdc++.h>
using namespace std;
#define int long long
#define fer(i,a,b) for(int i=a;i<b;i++)
signed main(){
    cout<<"拉格朗日插值法，请输入插值点个数n：";
    int n;cin>>n;
    printf("请输入%d个插值点x值（等距）：",n);
    double fx[n],x[n];
    fer(i,0,n){
        cin>>x[i];
    }//{24 26 28 30}{1.888175 1.918645 1.947294 1.961009};
    printf("请输入%d个插值点f(x)值：",n);
    fer(i,0,n){
        cin>>fx[i];
    }
    int m;
    printf("请输入待求点个数m：");
    cin>>m; 
    double targetx[m];//{25 27 29};
    printf("请输入%d个待求点x值：",m);
    fer(i,0,m){
        cin>>targetx[i];
    }
    double phi[n];//系数
    for(int i=0;i<m;i+=1){
        fer(j,0,n)phi[j]=1;//初始化
        fer(j,0,n){
            fer(k,0,n){
                if(j!=k){
                    phi[j]*=(targetx[i]-x[k]);
                    phi[j]/=(x[j]-x[k]);
                }
            }
        }
        double res=0;  
        fer(j,0,n){
            res+=phi[j]*fx[j];
            //cout<<i<<" "<<phi[i]<<" "<<data[i]<<" "<<res<<endl;
        }
        cout<<"x="<<targetx[i]<<" , L(x)="<<res<<endl;
    }
    return 0;
}

牛顿插值方法

#include<bits/stdc++.h>
using namespace std;
#define int long long
#define fer(i,a,b) for(int i=a;i<b;i++)
signed main(){
    cout<<"牛顿插值法，请输入插值点个数n：";
    int n;cin>>n;
    double data[n];//={0.41075 0.57815 0.69675 0.88811 1.02652};
    double a[n];//={0.4 0.55 0.65 0.8 0.9};
    printf("请输入%d个插值点x值：",n);
    fer(i,0,n){
        cin>>a[i];
    }
    printf("请输入%d个插值点f(x)值：",n);
    fer(i,0,n){
        cin>>data[i];
    }
    double dp[n][n+1];
    fer(i,0,n){
        dp[i][0]=a[i];
        dp[i][1]=data[i];
    }
    fer(j,2,n+1){
        fer(i,j-1,n){
            dp[i][j]=(dp[i][j-1]-dp[i-1][j-1])/(dp[i][0]-dp[i-j+1][0]);
        }
    }
    cout<<"差商结果如下："<<endl;
    cout<<"x        f(x)     ";
    fer(i,0,n-1)cout<<i+1<<"阶差商  ";
    cout<<endl;
    fer(i,0,n){
        fer(j,0,i+2){
            cout<<left<<setw(9)<<dp[i][j]<<" ";
        }
        cout<<endl;
    }
    cout<<"请输入待求点个数m：";
    int m;cin>>m;
    double targetx[m];
    printf("请输入%d个待求点x值：",m);//0.895
    fer(i,0,m){
        cin>>targetx[i];
    }
    
    for(int x=0;x<m;x++){
        double res=0;
        double now;
        fer(i,0,n){
            now=dp[i][i+1];
            fer(j,0,i){
                now*=(targetx[x]-a[j]);
            }
            res+=now;
        }
        cout<<"x="<<targetx[x]<<" , p(x)="<<res<<endl;
    }
    return 0;
}

Newton-Cotes 方法

计算以下积分值：
在这里插入图片描述

#include<bits/stdc++.h>
using namespace std;
#define int long long
#define fer(i,a,b) for(int i=a;i<b;i++)
#define E  2.7182818284590452354
double trapezoid(double down,double up,double fx[]){//积分下限、上限、插值点 
    //梯形求积公式
    double res=(up-down)/2;
    res*=(fx[0]+fx[1]);
    return res;
}
double simpson(double down,double up,double fx[]){
    double res=(up-down)/6;
    res*=(fx[0]+4*fx[1]+fx[2]);
    return res;
}
double cotes(double down,double up,double fx[]){
    double res=(up-down)/90;
    res*=(7*fx[0]+32*fx[1]+12*fx[2]+32*fx[3]+7*fx[4]);
    return res;
}
double fx1(double x){
    double res=4-sin(x)*sin(x);
    res=sqrt(res);
    return res;
}
double fx2(double x){
    if(x==0)return 1;
    double res=sin(x)/x;
    return res;
}
double fx3(double x){
    double res=pow(E,x);
    res/=(4+x*x);
    return res;
}
double fx4(double x){
    double res=log(1+x);
    res/=(1+x*x);
    return res;
}
signed main(){
    cout<<"牛顿-柯特斯公式"<<endl;
    cout<<"积分1:f(x)=sqrt(4-sin(x)^2)"<<endl;
    cout<<"请输入积分下限和上限（小数输入）:";
    double a,b;cin>>a>>b;
    cout<<"当求积节点个数=2时，使用梯形求积公式，积分结果为：";
    double trapex[2],trapefx[2];
    trapex[0]=a;trapex[1]=b;
    fer(i,0,2){
        trapefx[i]=fx1(trapex[i]);
    }
    double res=trapezoid(a,b,trapefx);
    cout<<setprecision(16)<<res<<endl;
    cout<<"当求积节点个数=3时，使用辛普森求积公式，积分结果为：";
    double simpsonx[3],simpsonfx[3];
    simpsonx[0]=a;simpsonx[1]=(a+b)/2;simpsonx[3]=b;
    fer(i,0,3){
        simpsonfx[i]=fx1(simpsonx[i]);
    }
    res=simpson(a,b,simpsonfx);
    cout<<setprecision(16)<<res<<endl;
    cout<<"当求积节点个数=5时，使用柯特斯求积公式，积分结果为：";
    double cotesx[5],cotesfx[5];
    cotesx[0]=a;cotesx[1]=(a+b)/4;cotesx[2]=(a+b)/2;cotesx[3]=(a+b)/4*3;cotesx[4]=b;
    fer(i,0,5){
        cotesfx[i]=fx1(cotesx[i]);
    }
    res=cotes(a,b,cotesfx);
    cout<<setprecision(16)<<res<<endl<<endl;
    
    cout<<"积分2:f(x)=sinx/x"<<endl;
    cout<<"请输入积分下限和上限（小数输入）:";
    cin>>a>>b;
    cout<<"当求积节点个数=2时，使用梯形求积公式，积分结果为：";
    trapex[0]=a;trapex[1]=b;
    fer(i,0,2){
        trapefx[i]=fx2(trapex[i]);
    }
    res=trapezoid(a,b,trapefx);
    cout<<setprecision(16)<<res<<endl;
    cout<<"当求积节点个数=3时，使用辛普森求积公式，积分结果为：";
    simpsonx[0]=a;simpsonx[1]=(a+b)/2;simpsonx[3]=b;
    fer(i,0,3){
        simpsonfx[i]=fx2(simpsonx[i]);
    }
    res=simpson(a,b,simpsonfx);
    cout<<setprecision(16)<<res<<endl;
    cout<<"当求积节点个数=5时，使用柯特斯求积公式，积分结果为：";
    cotesx[0]=a;cotesx[1]=(a+b)/4;cotesx[2]=(a+b)/2;cotesx[3]=(a+b)/4*3;cotesx[4]=b;s
    fer(i,0,5){
        cotesfx[i]=fx2(cotesx[i]);
    }
    res=cotes(a,b,cotesfx);
    cout<<setprecision(16)<<res<<endl<<endl;
    
    cout<<"积分3:f(x)=e^x/(4+x^2)"<<endl;
    cout<<"请输入积分下限和上限（小数输入）:";
    cin>>a>>b;
    cout<<"当求积节点个数=2时，使用梯形求积公式，积分结果为：";
    trapex[0]=a;trapex[1]=b;
    fer(i,0,2){
        trapefx[i]=fx3(trapex[i]);
    }
    res=trapezoid(a,b,trapefx);
    cout<<setprecision(16)<<res<<endl;
    cout<<"当求积节点个数=3时，使用辛普森求积公式，积分结果为：";
    simpsonx[0]=a;simpsonx[1]=(a+b)/2;simpsonx[3]=b;
    fer(i,0,3){
        simpsonfx[i]=fx3(simpsonx[i]);
    }
    res=simpson(a,b,simpsonfx);
    cout<<setprecision(16)<<res<<endl;
    cout<<"当求积节点个数=5时，使用柯特斯求积公式，积分结果为：";
    cotesx[0]=a;cotesx[1]=(a+b)/4;cotesx[2]=(a+b)/2;cotesx[3]=(a+b)/4*3;cotesx[4]=b;
    fer(i,0,5){
        cotesfx[i]=fx3(cotesx[i]);
    }
    res=cotes(a,b,cotesfx);
    cout<<setprecision(16)<<res<<endl<<endl;
    
    cout<<"积分4:f(x)=ln(1+x)/(1+x^2)"<<endl;
    cout<<"请输入积分下限和上限（小数输入）:";
    cin>>a>>b;
    cout<<"当求积节点个数=2时，使用梯形求积公式，积分结果为：";
    trapex[0]=a;trapex[1]=b;
    fer(i,0,2){
        trapefx[i]=fx4(trapex[i]);
    }
    res=trapezoid(a,b,trapefx);
    cout<<setprecision(16)<<res<<endl;
    cout<<"当求积节点个数=3时，使用辛普森求积公式，积分结果为：";
    simpsonx[0]=a;simpsonx[1]=(a+b)/2;simpsonx[3]=b;
    fer(i,0,3){
        simpsonfx[i]=fx4(simpsonx[i]);
    }
    res=simpson(a,b,simpsonfx);
    cout<<setprecision(16)<<res<<endl;
    cout<<"当求积节点个数=5时，使用柯特斯求积公式，积分结果为：";
    cotesx[0]=a;cotesx[1]=(a+b)/4;cotesx[2]=(a+b)/2;cotesx[3]=(a+b)/4*3;cotesx[4]=b;
    fer(i,0,5){
        cotesfx[i]=fx4(cotesx[i]);
    }
    res=cotes(a,b,cotesfx);
    cout<<setprecision(16)<<res<<endl<<endl;
    return 0;
}

求非线性方程根的牛顿法

用牛顿迭代法求 xe^x − 1 = 0 的根，迭代初始值为 x0 = 0.5。

#include<bits/stdc++.h>
using namespace std;
#define int long long
#define fer(i,a,b) for(int i=a;i<b;i++)
signed main(){
    cout<<"牛顿迭代法，所求方程为：xe^x-1=0"<<endl;
    cout<<"请输入初值：";
    double x;cin>>x;
    cout<<"请输入最大迭代次数:";
    int n;cin>>n;
    cout<<"请输入精度要求：";
    double epsilon;cin>>epsilon;
    bool flag=0;
    for(int i=0;i<n;i++){
        double f=x*exp(x)-1;
        double df=exp(x)+x*exp(x);
        double x1=x-f/df;
        cout<<"第"<<i+1<<"次迭代，x="<<x1<<endl;
        if(abs(x1-x)<epsilon){
            cout<<"精度已达要求"<<endl;
            flag=1;
            break;
        }
        x=x1;
    }
    if(flag==0)cout<<"迭代次数已达上限"<<endl;
    return 0;
}

高斯-赛德尔迭代法解线性方程组

#include<bits/stdc++.h>
using namespace std;
#define int long long
#define fer(i,a,b) for(int i=a;i<b;i++)

signed main(){
    cout<<"Gauss-Seidel迭代法解线性方程组"<<endl;
    cout<<"请输入矩阵维数n:";
    int n;cin>>n;
    double a[n][n],b[n];
    cout<<"请输入增广矩阵("<<n<<"x"<<n+1<<"):";
    fer(i,0,n){
        fer(j,0,n){
            cin>>a[i][j];
        }
        cin>>b[i];
    }
    cout<<"请输入迭代初值向量:";
    double x[n];
    fer(i,0,n)cin>>x[i];
    
    cout<<"请输入精度要求：";
    double epsilon;cin>>epsilon;
    cout<<"请输入最大迭代次数:";
    int m;cin>>m;
    
    double phi[n][n];
    fer(i,0,n){
        fer(j,0,n){
            if(j==i)phi[i][j]=0;
            else{
                phi[i][j]=-a[i][j]/a[i][i];
            }
        }
    }
    // 10 -1 -2 7.2  -1 10 -2 8.3  -1 -1 5 4.2
    bool flag=0;
    double x1[n];
    fer(k,0,m){
        fer(i,0,n){
            x1[i]=b[i]/a[i][i];
            fer(j,0,n){
                x1[i]+=phi[i][j]*x[j];
            }
            if(abs(x1[i]-x[i])<epsilon){
                
                flag=1;
                break;
            }
            x[i]=x1[i];
        }
        cout<<"第"<<k+1<<"次迭代，x=[";
        fer(i,0,n){
            cout<<setprecision(10)<<x[i];
if(i!=n-1)cout<<"  ";
        }
        cout<<"]"<<endl;
        if(flag){
            cout<<"精度已达要求"<<endl;
            break;
        }
    }
    if(flag==0)cout<<"迭代次数已达上限"<<endl;
    return 0;
}

高斯消元法求解线性方程组

#include<bits/stdc++.h>
using namespace std;
#define int long long
#define fer(i,a,b) for(int i=a;i<b;i++)
#define E  2.7182818284590452354
signed main(){
    cout<<"高斯消元法"<<endl;
    cout<<"请输入矩阵维数n:";
    int n;cin>>n;
    double a[n][n],b[n];
    cout<<"请输入增广矩阵("<<n<<"x"<<n+1<<"):";
    fer(i,0,n){
        fer(j,0,n){
            cin>>a[i][j];
        }
        cin>>b[i];
    }   // 10 -1 -2 7.2  -1 10 -2 8.3  -1 -1 5 4.2
    double phi;
    fer(k,0,n-1){//用于消元的行 
        fer(i,k+1,n){//被消元的行 
            phi=-a[i][k]/a[k][k];//消元系数 
            fer(j,k,n){
                a[i][j]+=phi*a[k][j];
            }
            b[i]+=phi*b[k];
        }
    }
    double x[n];
    for(int i=n-1;i>=0;i--){ 
        x[i]=b[i];
        fer(j,i+1,n){
            x[i]-=a[i][j]*x[j];
        }
        x[i]/=a[i][i];
    }
    cout<<"x=[";
    fer(i,0,n){
        cout<<x[i]; 
        if(i!=n-1)cout<<" ";
    }
    cout<<"]"<<endl;
    return 0;
}

Doolittle 分解法求解线性方程组

#include<bits/stdc++.h>
using namespace std;
#define int long long
#define fer(i,a,b) for(int i=a;i<b;i++)

signed main(){
    cout<<"Doolittle分解法解线性方程组"<<endl;
    cout<<"请输入矩阵维数n:";
    int n;cin>>n;
    double a[n][n],b[n];
    cout<<"请输入增广矩阵("<<n<<"x"<<n+1<<"):";
    fer(i,0,n){
        fer(j,0,n){
            cin>>a[i][j];
        }
        cin>>b[i];
    }
    double l[n][n],u[n][n];
    fer(i,0,n){
        fer(j,0,i)u[i][j]=0;
        fer(j,i,n){
            u[i][j]=a[i][j];
            fer(k,0,i){
                u[i][j]-=l[i][k]*u[k][j];
            }
        }
        fer(j,0,i)l[j][i]=0;
        l[i][i]=1;
        fer(j,i+1,n){//计算L,j是行标 
            l[j][i]=a[j][i];
            fer(k,0,i){
                l[j][i]-=l[j][k]*u[k][i];
            }
            l[j][i]/=u[i][i];
        }
        
    }
    cout<<"L="<<endl;
    fer(i,0,n){
        fer(j,0,n)cout<<setw(10)<<l[i][j]<<" ";
        cout<<endl;
    }
    cout<<"U="<<endl;
    fer(i,0,n){
        fer(j,0,n)cout<<setw(10)<<u[i][j]<<" ";
        cout<<endl;
    }
    double y[n];
    fer(i,0,n){//Ly=b,求y 
        y[i]=b[i];
        fer(j,0,i)y[i]-=l[i][j]*y[j];
    }
    double x[n];
    for(int i=n-1;i>=0;i--){
        x[i]=y[i];
        fer(j,i+1,n){
            x[i]-=u[i][j]*x[j];
        }
        x[i]/=u[i][i];
    }
    cout<<"x=[";
    fer(i,0,n){
            cout<<setprecision(10)<<x[i];
            if(i!=n-1)cout<<"  ";
        }
    cout<<"]"<<endl;
    // 10 -1 -2 7.2  -1 10 -2 8.3  -1 -1 5 4.2
    
    return 0;
}

欧拉法求解常微分方程

使用常微分方程例子如下：
在这里插入图片描述

#include<bits/stdc++.h>
using namespace std;
#define int long long
#define fer(i,a,b) for(int i=a;i<b;i++)
double f(double x,double y){
    return 3*x-2*y*y-12;
}
signed main(){
    cout<<"求解常微分方程，方程：y'=3x-2y^2-12"<<endl; 
    double x,y,h;
    cout<<"请输入初值x,f(x)：";
    cin>>x>>y;
    cout<<"请输入步长h：";
    cin>>h;
    cout<<"请输入x上限：";
    double n;cin>>n;
    int k=n/h; 
    cout<<"欧拉法:"<<endl;
    double x1=x,y1=y;
    cout<<"f("<<x1<<")="<<y1<<endl;
    fer(i,0,k){
        double fxy=f(x1,y1);
        x1+=h;
        y1=y1+h*fxy;
        cout<<"f("<<x1<<")="<<y1<<endl;
    }
    cout<<endl<<"改进的欧拉法:"<<endl; 
    x1=x;
    y1=y;
    cout<<"f("<<x1<<")="<<y1<<endl;
    fer(i,0,k){
        double forcasty=y1+h*f(x1,y1);
        y1=y1+h/2.0*(f(x1,y1)+f(x1+h,forcasty));
        x1+=h;
        cout<<"f("<<x1<<")="<<y1<<endl;
    }
    return 0;
}
sylviiiiiia
关注
专栏目录
学习笔记：拉格朗日插值法的推导以及C++程序的实现
m0_54563743的博客
03-30 3647
概要：拉格朗日插值法是数值分析中最重要的方法之一。给定n+1对数组，分别记为(x1,y1),(x2,y2),……,(xn+1,yn+1),通过对这n+1对数组的拟合，可以得到一个n+1次的多项式Pn+1(x)，从而将x值代入即可推测y值。当min(x1,x2,……,xn+1)<x<max(x1,x2,x3,……，xn+1)时称为内插，当x<min(x1,x2,……,xn+1)或x>max(x1,x2,……,xn+1)称为外插。一般来说，内插的精度会比外插好。
拉格朗日插值算法（附c++源码）
热门推荐
double_sweet1的博客
05-10 1万+
C++程序实现Lagrange插值公式 Lagrange插值公式，是属于数值分析方面的内容，关于其应用，在这里就不多说。此处我想用C语言程序来实现n各插值节点插值公式的求解，并求出在某一个插值节点对应的函数值。 对于Lagrange插值算法的基本思想，在这里我只想略提两点，一个是拉格朗日插值公式，一个是拉格朗日插值基函数的求解。因为这两者才是算法需要解决的最根本的问题。 （1）采用插...
插值（二）——拉格朗日插值（C++）
最新发布
m0_50793313的博客
02-11 1065
使用C++实现Lagrange插值
C++：Lagrange插值方法
weixin_44575323的博客
12-24 2169
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录前言一、Lagrange形式二、程序算法三、病态问题总结 前言 本篇文章是在学习计算方法后，尝试用Lagrange插值方法进行插值，其中遇到了一些问题，询问了一下别人得到了解决方法，因此写下了这篇文章。 提示：以下是本篇文章正文内容，下面案例可供参考 一、Lagrange形式 为了构造出Lagrange形式的插值公式，可以先作插值数据点 {(x0x_0x0​,0),(x1x_1x1​,0),…,(xi−1x_{i-1}xi−
数值分析：拉格朗日插值法笔记以及C++代码实现
你好
11-15 4818
在实际应用中常常需要根据已知的函数点进行数据、模型的处理和分析，而有时候现有的数据是极少的，不足以支撑分析的进行，这时就需要使用一些数学的方法“模拟产生”一些新的但又比较靠谱的值来满足需求，这就是插值的作用。
常用数值计算方法C++源代码
10-11
这里我们主要探讨的是使用C++编程语言实现的一些经典数值计算方法，包括拉格朗日插值多项式、牛顿值多项式、二分法、龙格-库塔算法、高斯-赛德尔迭代法、牛顿迭代法、列主元高斯消去法、雅可比迭代法、四阶阿当姆斯...
《数值计算方法》C++代码与数据结果
01-14
《数值计算方法》是计算机科学领域中一门重要的课程，它主要研究如何用计算机解决数学上的数值问题。在C++编程语言中实现数值计算方法，能够高效地处理各种复杂的科学计算任务。这个压缩包包含了该课程相关的C++源...
数值计算方法中的典型方法使用c++代码实现
10-29
本项目聚焦于将数值计算方法的典型方法用c++进行编码，旨在帮助学习者理解和应用这些方法。以下是关于这些方法的详细介绍： 1. 最小二乘法（Least Squares Method）： 最小二乘法是解决非线性或线性回归问题的一种...
数值计算方法代码
08-18
该资源可用于数值计算方法课程所学的方法在c语言中的应用，其中包括秦九韶算法，二分法，迭代法，列主元消去法，矩阵三角分解法，插值法等，
机械臂运动学C++代码
07-22
总的来说，这个“机械臂运动学C++代码”资源为学习者提供了一个实际操作的平台，通过编程实现机械臂的运动学计算，有助于深入理解和掌握相关理论。对于学习C++编程、机器人控制、以及自动化的学生和工程师来说，这是...
基于c++语言实现拉格朗日插值
10-30
本文采用C++编程语言实现数值分析中的拉格朗日插值，使用于初学者
拉格朗日插值C++实现（改进版）
03-29
这次修补了上次的一个漏洞，同时还新增加一个功能，详细情况参阅说明文件“readme.txt"
拉格朗日插值法C代码
10-14
根据拉格朗日插值法编写的完整C代码，很方便，只需输入节点数和节点数据以及插入的数据。
拉格朗日插值算法C++实现
08-16
拉格朗日插值算法C++实现，简单demo
数值分析C++实现拉格朗日（Lagrange）插值多项式
陌意随影的博客
05-05 4400
数值分析实验：已知插值节点序列，用拉格朗日（Lagrange）插值多项式计算函数L0(x)计算函数f(x)在点x0的近似值。 首先给出算法描述： （1）给已知条件（X0,y0），（X1,y1），（X2,y2），…，（Xn,yn）点进行对应的包装操作和编号处理 （2）根据已知条件（X0,y0），（X1,y1），（X2,y2），…，（Xn,yn）和要求解的x值计算拉格朗日基函数: 2.1 首先计算每个...
“C++实现重心拉格朗日多项式插值算法——数据拟合神器“
2301_79326510的博客
08-31 287
在上述代码中，构造函数的主要功能是将传递进来的数据点存储到LagrangePolynomial类的私有成员变量中。在这个内层循环中，我们计算了基函数w的值，其中w表示插值多项式中的每个项。在上述代码中，Evaluate()函数是主要的计算函数，用来对于给定的x坐标求出多项式函数的y坐标值。析构函数用来释放内存。通过本篇文章的介绍，读者可以了解到如何在C++中实现重心拉格朗日多项式，并进行数据拟合。首先，我们需要定义一个重心拉格朗日多项式的类，其中包含插值数据的x和y坐标值，以及多项式的次数n。
【数值分析】拉格朗日插值法与牛顿插值法的C++实现
Cxj__的博客
12-13 3806
插值法就是利用一系列的点来构造插值函数对原函数进行近似，构造的插值函数必须满足插值节点的要求。拉格朗日插值法构造拉格朗日基函数较为简单，但是当增加或减少插值节点时拉格朗日基函数就需要重新计算；而牛顿插值法利用差商表（有点类似动态规划）来构建插值函数，当函数增加一个节点时只需要在原来的基础上增加一项即可。
拉格朗日插值(Lagrange)C++实现
ADemon的专栏
03-18 2397
#include // w_{n+1}(x)// x:变量x; n:插值多项式次数; xn:x_{n}数组(长度至少为n + 1)double w(double x, int n, std::vector xn) { if (n > (int) xn.size() - 1) { n = (int) xn.size() - 1; }
拉格朗日插值、牛顿插值C++实现
GTC的博客
12-11 1521
拉格朗日插值、牛顿差值C++实现
C++实现数值计算插值方法的代码解析
资源摘要信息:"本文将探讨数值计算领域中的积分方法，并结合C++编程语言，具体阐述插值法的实现细节。通过提供的文件名aux_interpolation.cpp和aux_interpolation.h，我们可以深入理解插值算法如何在实际编程中得到...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值